Appender.cpp

Go to the documentation of this file.

#include "logging/Appender.hpp"
#include "ocl/Component.hpp"

#include <log4cpp/Appender.hh>
#include <log4cpp/BasicLayout.hh>
#include <log4cpp/SimpleLayout.hh>
#include <log4cpp/PatternLayout.hh>

namespace OCL {
namespace logging {

Appender::Appender(std::string name) :
    RTT::TaskContext(name, RTT::TaskContext::PreOperational), 
        appender(0),
        layoutName_prop("LayoutName", "Layout name (e.g. 'simple', 'pattern')"),
        layoutPattern_prop("LayoutPattern", "Layout conversion pattern (for those layouts that use a pattern)"),
        countMaxPopped(0)
{
    ports()->addEventPort("LogPort", log_port );

    properties()->addProperty(layoutName_prop);
    properties()->addProperty(layoutPattern_prop);
}

Appender::~Appender()
{
}

bool Appender::configureLayout()
{
    bool rc;
    const std::string& layoutName       = layoutName_prop.rvalue();
    const std::string& layoutPattern    = layoutPattern_prop.rvalue();

    rc = true;          // prove otherwise
    if (appender && 
        (!layoutName.empty()))
    {
        // \todo layout factory??
        if (0 == layoutName.compare("basic"))
        {
            appender->setLayout(new log4cpp::BasicLayout());
        }
        else if (0 == layoutName.compare("simple"))
        {
            appender->setLayout(new log4cpp::SimpleLayout());
        }
        else if (0 == layoutName.compare("pattern")) 
        {
            log4cpp::PatternLayout *layout = new log4cpp::PatternLayout();
            layout->setConversionPattern(layoutPattern);
                        appender->setLayout(layout);
            // the layout is now owned by the appender, and will be deleted
            // by it when the appender is destroyed
        }
        else 
        {
            RTT::log(RTT::Error) << "Invalid layout '" << layoutName
                       << "' in configuration for category: "
                       << getName() << RTT::endlog();
            rc = false;
        }
    }

    return rc;
}
    
bool Appender::startHook()
{
//    return log_port.ready();  

    return true;
}

void Appender::stopHook()
{
        drainBuffer();

        // introduce event to log diagnostics
        if (0 != appender)
        {
                /* place a "#" at the front of the message, for appenders that are
                 reporting data for post-processing. These particular appenders
                 don't prepend the time data (it's one at time of sampling).
                 This way gnuplot, etc., ignore this diagnostic data.
                */
                std::stringstream       ss;
                ss << "# countMaxPopped=" << countMaxPopped;
                log4cpp::LoggingEvent   event("OCL.logging.Appender",
                                                                          ss.str(),
                                                                          "",
                                                                          log4cpp::Priority::DEBUG);
                appender->doAppend(event);
        }
}

void Appender::drainBuffer()
{
        processEvents(0);
}

void Appender::processEvents(int n)
{
    if (!log_port.connected()) return;      // no category connected to us
        if (!appender) return;                          // no appender!?

        // check pre-conditions
        if (0 > n) n = 1;

    /* Consume waiting events until
       a) the buffer is empty
       b) we consume enough events
        */
    OCL::logging::LoggingEvent  event;
        bool                                            again = false;
        int                                                     count = 0;

        do
        {
        if (log_port.read( event ) == RTT::NewData)
                {
                        ++count;

                        appender->doAppend( event.toLog4cpp() );

                        // Consume infinite events OR up to n events
                        again = (0 == n) || (count < n);
                        if ((0 != n) && (count == n)) ++countMaxPopped;
                }
                else
                {
                        break;      // nothing to do
                }
        }
        while (again);
}

// namespaces
}
}

ORO_LIST_COMPONENT_TYPE(OCL::logging::Appender);