lsst::log::detail::PyLogAppender Class Reference

This class defines special log4cxx appender which "appends" log messages to Python logging. More...

#include <PyLogAppender.h>

Inheritance diagram for lsst::log::detail::PyLogAppender:

Public Member Functions
	PyLogAppender ()
	PyLogAppender (const PyLogAppender &)=delete
PyLogAppender &	operator= (const PyLogAppender &)=delete
void	append (const spi::LoggingEventPtr &event, log4cxx::helpers::Pool &p) override
	Forward the event to Python logging.
void	close () override
	Close this appender instance, this is no-op.
bool	requiresLayout () const override
	Returns true if appender "requires" layout to be defined for it.
void	setOption (const LogString &option, const LogString &value) override
	Handle configuration options.

Detailed Description

This class defines special log4cxx appender which "appends" log messages to Python logging.

To use this logger one has to explicitly add it to log4cxx configuration using PyLogAppender as appender class name, for example:

log4j.rootLogger = INFO, PyLog
log4j.appender.PyLog = PyLogAppender
log4j.appender.PyLog.layout = org.apache.log4j.PatternLayout
log4j.appender.PyLog.layout.ConversionPattern = %m (%X{LABEL})

Definition at line 58 of file PyLogAppender.h.

Constructor & Destructor Documentation

PyLogAppender() [1/2]

lsst::log::detail::PyLogAppender::PyLogAppender

(

)

Definition at line 77 of file PyLogAppender.cc.

                             {
 
    GilGuard gil_guard;
 
    PyObjectPtr logging(PyImport_ImportModule("logging"));
    if (logging == nullptr) {
        ::reraise("ImportError: Failed to import Python logging module");
    }
    _getLogger = PyObject_GetAttrString(logging, "getLogger");
    if (_getLogger == nullptr) {
        ::reraise("AttributeError: logging.getLogger method does not exist");
    }
 
    PyObjectPtr lsstlog_module(PyImport_ImportModule("lsst.log"));
    if (lsstlog_module == nullptr) {
        ::reraise("ImportError: Failed to import lsst.log module");
    }
    _mdc_class = PyObject_GetAttrString(lsstlog_module, "MDCDict");
    if (_mdc_class == nullptr) {
        ::reraise("AttributeError: lsst.log.MDCDict class does not exist");
    }
}

PyLogAppender() [2/2]

lsst::log::detail::PyLogAppender::PyLogAppender ( const PyLogAppender & )

delete

Member Function Documentation

append()

void lsst::log::detail::PyLogAppender::append ( const spi::LoggingEventPtr & event, log4cxx::helpers::Pool & p )

override

Forward the event to Python logging.

Definition at line 100 of file PyLogAppender.cc.

                                                                                 {
 
    // logger name, UTF-8 encoded
    std::string logger_name;
    log4cxx::helpers::Transcoder::encodeUTF8(event->getLoggerName(), logger_name);
    int const level = event->getLevel()->toInt();
    int const pyLevel = level / 1000;
 
    // Check logger name in cache first, this does not need GIL but needs
    // synchronization
    PyObjectPtr logger;
    {
        std::lock_guard<std::mutex> lock(_cache_mutex);
        auto cache_iter = _cache.find(logger_name);
        if (cache_iter != _cache.end()) {
            // use it, age is updated later
            logger = cache_iter->second.logger;
        }
    }
 
    // Need Python at this point
    GilGuard gil_guard;
 
    if (logger == nullptr) {
        // was not found in cache get one from Python
        if (logger_name == "root") {
            logger = PyObject_CallFunction(_getLogger, nullptr);
        } else {
            logger = PyObject_CallFunction(_getLogger, "s", logger_name.c_str());
        }
    }
    if (logger == nullptr) {
        ::reraise("Failed to retrieve Python logger \"" + logger_name + "\"");
    } else {
        // remember it in cache
        std::lock_guard<std::mutex> lock(_cache_mutex);
        _cache.emplace(logger_name, LRUEntry({logger, _lru_age ++}));
        while (_cache.size() > ::MAX_LRU_CACHE_SIZE) {
            // find oldest element and remove
            auto iter = std::min_element(
                _cache.begin(), _cache.end(),
                [](const LRUCache::value_type& lhs, const LRUCache::value_type& rhs) {
                    return lhs.second.age < rhs.second.age;
                }
            );
            _cache.erase(iter);
        }
        // Age counter could potentially overflow (wrap to 0), reset age for
        // all cache entries to avoid issues.
        if (_lru_age == 0) {
            for (auto& cache_value: _cache) {
                // give them different but "random" ages
                cache_value.second.age = _lru_age ++;
            }
        }
    }
 
    // before doing anything check logging level
    PyObjectPtr py_is_enabled(PyObject_CallMethod(logger, "isEnabledFor", "i", pyLevel));
    if (py_is_enabled == nullptr) {
        ::reraise("Failure when calling logger.isEnabledFor() method");
    }
    if (not PyObject_IsTrue(py_is_enabled)) {
        return;
    }
 
    // collect all necessary info
    auto& loc = event->getLocationInformation();
    std::string file_name;
    if (loc.getFileName() != nullptr) {
        file_name = loc.getFileName();
    }
    int const lineno = loc.getLineNumber();
 
    // if layout is defined then use formatted message
    std::string message;
    if (this->getLayout()) {
        LogString msg;
        this->getLayout()->format(msg, event, p);
        // get rid of trailing new-line, just in case someone uses %n in format
        if (not msg.empty() and msg.back() == '\n') {
            msg.pop_back();
        }
        log4cxx::helpers::Transcoder::encodeUTF8(msg, message);
    } else {
        log4cxx::helpers::Transcoder::encodeUTF8(event->getMessage(), message);
    }
 
    // record = logger.makeRecord(name, level, fn, lno, msg, args, exc_info,
    //                            func=None, extra=None, sinfo=None)
    // I would like to pass MDC as an `extra` argument but that does not
    // work reliably in case we want to override record factory.
    PyObjectPtr record(PyObject_CallMethod(logger, "makeRecord", "sisisOO",
                                            logger_name.c_str(),
                                            pyLevel,
                                            file_name.c_str(),
                                            lineno,
                                            message.c_str(),
                                            Py_None,
                                            Py_None));
    if (record == nullptr) {
        ::reraise("Failed to create LogRecord instance");
    }
 
    // Record should already have an `MDC` attribute added by a record factory,
    // and it may be pre-filled with some info by the same factory. Here we
    // assume that if it already exists then it is dict-like, if it does not
    // we add this attribute as lsst.log.MDCDict instance (which is a dict with
    // some extra niceties).
 
    // mdc = getattr(record, "MDC")
    PyObjectPtr mdc(PyObject_GetAttrString(record, "MDC"));
    if (mdc == nullptr) {
        PyErr_Clear();
        // mdc = lsst.log.MDCDict()
        mdc = PyObject_CallObject(_mdc_class, nullptr);
        if (mdc == nullptr) {
            ::reraise("Failed to make MDCDict instance");
        }
        // record.MDC = mdc
        if (PyObject_SetAttrString(record, "MDC", mdc) == -1) {
            ::reraise("Failed to set LogRecord MDC attribute");
        }
    }
 
    // Copy MDC to dict, for key in getMDCKeySet(): mdc[key] = event.getMDC(key)
    for (auto& mdc_key: event->getMDCKeySet()) {
        std::string key, value;
        log4cxx::helpers::Transcoder::encodeUTF8(mdc_key, key);
        log4cxx::LogString mdc_value;
        event->getMDC(mdc_key, mdc_value);
        log4cxx::helpers::Transcoder::encodeUTF8(mdc_value, value);
        PyObjectPtr py_value(PyUnicode_FromStringAndSize(value.data(), value.size()));
        PyObjectPtr py_key(PyUnicode_FromStringAndSize(key.data(), key.size()));
        if (PyObject_SetItem(mdc, py_key, py_value) == -1) {
            // it is probably not a dictionary
            ::reraise("Failed to update MDC dictionary");
        }
    }
 
    // logger.handle(record)
    PyObjectPtr res(PyObject_CallMethod(logger, "handle", "O", record.get()));
    if (res == nullptr) {
        ::reraise("Logger failed to handle LogRecord");
    }
}

close()

void lsst::log::detail::PyLogAppender::close ( )

override

Close this appender instance, this is no-op.

Definition at line 247 of file PyLogAppender.cc.

                          {
}

operator=()

PyLogAppender & lsst::log::detail::PyLogAppender::operator= ( const PyLogAppender & )

delete

requiresLayout()

bool lsst::log::detail::PyLogAppender::requiresLayout ( ) const

override

Returns true if appender "requires" layout to be defined for it.

This appender returns false, we use layout but construct it differently.

Definition at line 250 of file PyLogAppender.cc.

                                         {
    return false;
}

setOption()

void lsst::log::detail::PyLogAppender::setOption ( const LogString & option, const LogString & value )

override

Handle configuration options.

Definition at line 254 of file PyLogAppender.cc.

                                                                             {
 
    if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("MESSAGEPATTERN"),
                                       LOG4CXX_STR("messagepattern"))) {
        setLayout(LayoutPtr(new PatternLayout(value)));
    } else {
        AppenderSkeleton::setOption(option, value);
    }
}

---

The documentation for this class was generated from the following files:

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-9.0.0/Linux64/log/gf0baf85859+c1f95f4921/python/lsst/log/log/PyLogAppender.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-9.0.0/Linux64/log/gf0baf85859+c1f95f4921/python/lsst/log/log/PyLogAppender.cc