示例#1
0
Filter::FilterDecision LevelRangeFilter::decide(
   const spi::LoggingEventPtr& event) const
{
   if (levelMin != 0 && !event->getLevel()->isGreaterOrEqual(levelMin))
   {
      // level of event is less than minimum
      return Filter::DENY;
   }

   if (levelMax != 0 && event->getLevel()->toInt() > levelMax->toInt())
   {
      // level of event is greater than maximum
      // Alas, there is no Level.isGreater method. and using
      // a combo of isGreaterOrEqual && !Equal seems worse than
      // checking the int values of the level objects..
      return Filter::DENY;
   }

   if (acceptOnMatch)
   {
      // this filter set up to bypass later filters and always return
      // accept if level in range
      return Filter::ACCEPT;
   }
   else
   {
      // event is ok for this filter; allow later filters to have a look..
      return Filter::NEUTRAL;
   }
}
示例#2
0
void AsyncAppender::append(const spi::LoggingEventPtr& event)
{
	// Set the NDC and thread name for the calling thread as these
	// LoggingEvent fields were not set at event creation time.
	event->getNDC();
	// Get a copy of this thread's MDC.
	event->getMDCCopy();
	
/*	if(locationInfo)
	{
		event.getLocationInformation();
	}*/
	
	synchronized sync(bf);

	while(bf->isFull())
	{
		//LOGLOG_DEBUG(_T("Waiting for free space in buffer, ")
		//	 << bf->length());
		bf->wait();
	}

	bf->put(event);
	if(bf->wasEmpty())
	{
		//LOGLOG_DEBUG(_T("Notifying dispatcher to process events."));
		bf->notify();
	}
}
void SimpleLayout::format(LogString& output,
   const spi::LoggingEventPtr& event,
   log4cxx::helpers::Pool&) const
{
        output.append(event->getLevel()->toString());
        output.append(LOG4CXX_STR(" - "));
        output.append(event->getRenderedMessage());
        output.append(LOG4CXX_EOL);
}
   /**
    * {@inheritDoc}
    */
 void append(const spi::LoggingEventPtr& event, log4cxx::helpers::Pool& p) {
       synchronized sync(blocker);
       VectorAppender::append(event, p);
         //
         //   if fatal, echo messages for testLoggingInDispatcher
         //
         if (event->getLevel() == Level::getInfo()) {
             LoggerPtr logger = Logger::getLoggerLS(event->getLoggerName());
             LOG4CXX_LOGLS(logger, Level::getError(), event->getMessage());
             LOG4CXX_LOGLS(logger, Level::getWarn(), event->getMessage());
             LOG4CXX_LOGLS(logger, Level::getInfo(), event->getMessage());
             LOG4CXX_LOGLS(logger, Level::getDebug(), event->getMessage());
         }
   }
示例#5
0
void SocketAppender::append(const spi::LoggingEventPtr& event, log4cxx::helpers::Pool& p) {
    if (oos != 0) {
        LogString ndcVal;
        event->getNDC(ndcVal);
        event->getThreadName();
        // Get a copy of this thread's MDC.
        event->getMDCCopy();
        try {
           event->write(*oos, p);
           oos->flush(p);
        } catch(std::exception& e) {
           oos = 0;
           LogLog::warn(LOG4CXX_STR("Detected problem with connection: "), e);
           if (getReconnectionDelay() > 0) {
               fireConnector();
           }
        }
    }
}
void SyslogAppender::append(const spi::LoggingEventPtr& event, Pool& p)
{
        if  (!isAsSevereAsThreshold(event->getLevel()))
                return;

        LogString msg;
        layout->format(msg, event, p);

// On the local host, we can directly use the system function 'syslog'
// if it is available
#if LOG4CXX_HAVE_SYSLOG
        if (sw == 0)
        {
                std::string sbuf;
                Transcoder::encode(msg, sbuf);

                // use of "%s" to avoid a security hole
                 ::syslog(syslogFacility | event->getLevel()->getSyslogEquivalent(),
                        "%s", sbuf.c_str());

                return;
        }
#endif

        // We must not attempt to append if sw is null.
        if(sw == 0)
        {
                errorHandler->error(LOG4CXX_STR("No syslog host is set for SyslogAppedender named \"")+
                        this->name+LOG4CXX_STR("\"."));
                return;
        }

        LogString sbuf(1, 0x3C /* '<' */);
        StringHelper::toString((syslogFacility | event->getLevel()->getSyslogEquivalent()), p, sbuf);
        sbuf.append(1, (logchar) 0x3E /* '>' */);
        if (facilityPrinting)
        {
                sbuf.append(facilityStr);
        }
        sbuf.append(msg);
        sw->write(sbuf);
}
void SocketHubAppender::append(const spi::LoggingEventPtr& event, Pool& p)
{

        // if no open connections, exit now
        if(streams.empty())
        {
                return;
        }
        
        LogString ndcVal;
        event->getNDC(ndcVal);
        event->getThreadName();
        // Get a copy of this thread's MDC.
        event->getMDCCopy();
       

        // loop through the current set of open connections, appending the event to each
        std::vector<ObjectOutputStreamPtr>::iterator it = streams.begin();
        std::vector<ObjectOutputStreamPtr>::iterator itEnd = streams.end();
        while(it != itEnd)
        {
                // list size changed unexpectedly? Just exit the append.
                if (*it == 0)
                {
                        break;
                }

                try
                {
                        event->write(**it, p);
                        (*it)->flush(p);
                        it++;
                }
                catch(std::exception& e)
                {
                        // there was an io exception so just drop the connection
                        it = streams.erase(it);
                        LogLog::debug(LOG4CXX_STR("dropped connection"), e);
                }
        }
}
void RH_LogEventAppender::append(const spi::LoggingEventPtr& event, Pool& p){
  if ( this->layout == NULL ) {
    LOG4CXX_ENCODE_CHAR(nameStr, name);
    std::string msg("No Layout set for the appender named [ ");
    msg.append(nameStr);
    msg.append(" ].");
	 
    LOG4CXX_DECODE_CHAR(msgL, msg);
    errorHandler->error(msgL);
    return;
  }
	 
  log4cxx::LogString fMsg;
	 
  this->layout->format(fMsg, event, p);
	 
  LOG4CXX_ENCODE_CHAR(fMsgStr, fMsg);

  // This is the message structure for a Redhawk logging event
  CF::LogEvent rh_event;
  LOG4CXX_ENCODE_CHAR(t1,prodId);
  rh_event.producerId = CORBA::string_dup(t1.c_str());
  LOG4CXX_ENCODE_CHAR(t2,prodName);
  rh_event.producerName = CORBA::string_dup(t2.c_str());
  LOG4CXX_ENCODE_CHAR(t3,prodFQN);
  rh_event.producerName_fqn = CORBA::string_dup(t3.c_str());

  CORBA::Long level=CF::LogLevels::FATAL;
  if ( event->getLevel() == log4cxx::Level::getError() )
    level=CF::LogLevels::ERROR;
  if ( event->getLevel() == log4cxx::Level::getWarn() )
    level=CF::LogLevels::WARN;
  if ( event->getLevel() == log4cxx::Level::getInfo() )
    level=CF::LogLevels::INFO;
  if ( event->getLevel() == log4cxx::Level::getDebug() )
    level=CF::LogLevels::DEBUG;
  if ( event->getLevel() == log4cxx::Level::getTrace() )
    level=CF::LogLevels::TRACE;
  if ( event->getLevel() == log4cxx::Level::getAll() )
    level=CF::LogLevels::ALL;
  rh_event.level = level;

  //timeStamp in LoggingEventPtr is in microseconds
  //need to convert to seconds for rh_event
  rh_event.timeStamp = event->getTimeStamp()/1000000;
  rh_event.msg = CORBA::string_dup(fMsg.c_str());
  
  // push log message to the event channel
  if ( _event_channel ) {
    if ( _event_channel->push(rh_event) != 0 ) {
      _LL_DEBUG( "RH_LogEventAppender::append EVENT CHANNEL, PUSH OPERATION FAILED.");
    }
 }
  
}
void AppenderSkeleton::doAppend(const spi::LoggingEventPtr& event, Pool& pool1)
{
        synchronized sync(mutex);


        if(closed)
        {
                LogLog::error(((LogString) LOG4CXX_STR("Attempted to append to closed appender named ["))
                      + name + LOG4CXX_STR("]."));
                return;
        }

        if(!isAsSevereAsThreshold(event->getLevel()))
        {
                return;
        }

        FilterPtr f = headFilter;


        while(f != 0)
        {
                 switch(f->decide(event))
                 {
                         case Filter::DENY:
                                 return;
                         case Filter::ACCEPT:
                                 f = 0;
                                 break;
                         case Filter::NEUTRAL:
                                 f = f->getNext();
                 }
        }

        append(event, pool1);
}
示例#10
0
void AsyncAppender::append(const spi::LoggingEventPtr& event, Pool& p) {
#if APR_HAS_THREADS
       //
        //   if dispatcher has died then
        //      append subsequent events synchronously
        //
        if (!dispatcher.isAlive() || bufferSize <= 0) {
            synchronized sync(appenders->getMutex());
            appenders->appendLoopOnAppenders(event, p);
            return;
        }

        // Set the NDC and thread name for the calling thread as these
        // LoggingEvent fields were not set at event creation time.
        LogString ndcVal;
        event->getNDC(ndcVal);
        event->getThreadName();
        // Get a copy of this thread's MDC.
        event->getMDCCopy();


        {
             synchronized sync(bufferMutex);
             while(true) {
                 int previousSize = buffer.size();
                 if (previousSize < bufferSize) {
                     buffer.push_back(event);
                     if (previousSize == 0) {
                        bufferNotEmpty.signalAll();
                     }
                     break;
                 }

                //
                //   Following code is only reachable if buffer is full
                //
                //
                //   if blocking and thread is not already interrupted
                //      and not the dispatcher then
                //      wait for a buffer notification
                bool discard = true;
                if (blocking
                    && !Thread::interrupted()
                    && !dispatcher.isCurrentThread()) {
                    try {
                        bufferNotFull.await(bufferMutex);
                        discard = false;
                    } catch (InterruptedException& e) {
                        //
                        //  reset interrupt status so
                        //    calling code can see interrupt on
                        //    their next wait or sleep.
                        Thread::currentThreadInterrupt();
                    }
                }

                //
                //   if blocking is false or thread has been interrupted
                //   add event to discard map.
                //
                if (discard) {
                    LogString loggerName = event->getLoggerName();
                    DiscardMap::iterator iter = discardMap->find(loggerName);
                    if (iter == discardMap->end()) {
                        DiscardSummary summary(event);
                        discardMap->insert(DiscardMap::value_type(loggerName, summary));
                    } else {
                        (*iter).second.add(event);
                    }
                    break;
                }
            }
        }
#else
        synchronized sync(appenders->getMutex());
        appenders->appendLoopOnAppenders(event, p);
#endif
  }
示例#11
0
void XMLLayout::format(LogString& output,
     const spi::LoggingEventPtr& event,
     Pool& p) const
{
        output.append(LOG4CXX_STR("<log4j:event logger=\""));
        Transform::appendEscapingTags(output, event->getLoggerName());
        output.append(LOG4CXX_STR("\" timestamp=\""));
        StringHelper::toString(event->getTimeStamp()/1000L, p, output);
        output.append(LOG4CXX_STR("\" level=\""));
        Transform::appendEscapingTags(output, event->getLevel()->toString());
        output.append(LOG4CXX_STR("\" thread=\""));
        Transform::appendEscapingTags(output, event->getThreadName());
        output.append(LOG4CXX_STR("\">"));
        output.append(LOG4CXX_EOL);

        output.append(LOG4CXX_STR("<log4j:message><![CDATA["));
        // Append the rendered message. Also make sure to escape any
        // existing CDATA sections.
        Transform::appendEscapingCDATA(output, event->getRenderedMessage());
        output.append(LOG4CXX_STR("]]></log4j:message>"));
        output.append(LOG4CXX_EOL);

        LogString ndc;
        if(event->getNDC(ndc)) {
                output.append(LOG4CXX_STR("<log4j:NDC><![CDATA["));
                Transform::appendEscapingCDATA(output, ndc);
                output.append(LOG4CXX_STR("]]></log4j:NDC>"));
                output.append(LOG4CXX_EOL);
        }

        if(locationInfo)
        {
                output.append(LOG4CXX_STR("<log4j:locationInfo class=\""));
                const LocationInfo& locInfo = event->getLocationInformation();
                LOG4CXX_DECODE_CHAR(className, locInfo.getClassName());
                Transform::appendEscapingTags(output, className);
                output.append(LOG4CXX_STR("\" method=\""));
                LOG4CXX_DECODE_CHAR(method, locInfo.getMethodName());
                Transform::appendEscapingTags(output, method);
                output.append(LOG4CXX_STR("\" file=\""));
                LOG4CXX_DECODE_CHAR(fileName, locInfo.getFileName());
                Transform::appendEscapingTags(output, fileName);
                output.append(LOG4CXX_STR("\" line=\""));
                StringHelper::toString(locInfo.getLineNumber(), p, output);
                output.append(LOG4CXX_STR("\"/>"));
                output.append(LOG4CXX_EOL);
        }
        
        if (properties) {
            KeySet propertySet(event->getPropertyKeySet());
            KeySet keySet(event->getMDCKeySet());
            if (!(keySet.empty() && propertySet.empty())) {
                output.append(LOG4CXX_STR("<log4j:properties>"));
                output.append(LOG4CXX_EOL);
                for (KeySet::const_iterator i = keySet.begin();
                        i != keySet.end(); 
                        i++) {
                        LogString key(*i);
                        LogString value;
                        if(event->getMDC(key, value)) {
                            output.append(LOG4CXX_STR("<log4j:data name=\""));
                            Transform::appendEscapingTags(output, key);
                            output.append(LOG4CXX_STR("\" value=\""));
                            Transform::appendEscapingTags(output, value);
                            output.append(LOG4CXX_STR("\"/>"));
                            output.append(LOG4CXX_EOL);
                        }
                }
            for (KeySet::const_iterator i2 = propertySet.begin();
                        i2 != propertySet.end(); 
                        i2++) {
                        LogString key(*i2);
                        LogString value;
                        if(event->getProperty(key, value)) {
                            output.append(LOG4CXX_STR("<log4j:data name=\""));
                            Transform::appendEscapingTags(output, key);
                            output.append(LOG4CXX_STR("\" value=\""));
                            Transform::appendEscapingTags(output, value);
                            output.append(LOG4CXX_STR("\"/>"));
                            output.append(LOG4CXX_EOL);
                        }
                }
                output.append(LOG4CXX_STR("</log4j:properties>"));
                output.append(LOG4CXX_EOL);
            }
        }

        output.append(LOG4CXX_STR("</log4j:event>"));
        output.append(LOG4CXX_EOL);
        output.append(LOG4CXX_EOL);        
}