cpp/html/_logging_8h_source.html

#pragma once


#include "RobotRaconteurConfig.h"

#include "RobotRaconteurConstants.h"

#include <boost/smart_ptr/intrusive_ref_counter.hpp>


#include <fstream>


namespace RobotRaconteur

{


class ROBOTRACONTEUR_CORE_API RobotRaconteurNode;

class ROBOTRACONTEUR_CORE_API MessageStringRef;


// Inspired by Boost.Log V2


class ROBOTRACONTEUR_CORE_API RRLogRecord

{

  public:

    RR_WEAK_PTR<RobotRaconteurNode> Node;

    RobotRaconteur_LogLevel Level;

    RobotRaconteur_LogComponent Component;

    std::string ComponentName;

    std::string ComponentObjectID;

    int64_t Endpoint;

    std::string ServicePath;

    std::string Member;

    std::string Message;

    boost::posix_time::ptime Time;

    std::string SourceFile;

    uint32_t SourceLine;

    std::string ThreadID;

    std::string FiberID;


    RRLogRecord();

};


ROBOTRACONTEUR_CORE_API std::ostream& operator<<(std::ostream& out, const RRLogRecord& record);


ROBOTRACONTEUR_CORE_API std::string RRLogRecord_Level_ToString(RobotRaconteur_LogLevel level);

ROBOTRACONTEUR_CORE_API std::string RRLogRecord_Component_ToString(RobotRaconteur_LogComponent component);

ROBOTRACONTEUR_CORE_API std::string RRLogRecord_Node_ToString(const RR_WEAK_PTR<RobotRaconteurNode>& node);


class ROBOTRACONTEUR_CORE_API RRLogRecordStream : public boost::intrusive_ref_counter<RRLogRecordStream>

{

  protected:

    RRLogRecord record;

    RR_SHARED_PTR<RobotRaconteurNode> node;

    std::stringstream ss;


  public:

    RRLogRecordStream(const RR_SHARED_PTR<RobotRaconteurNode>& node);

    RRLogRecordStream(const RR_SHARED_PTR<RobotRaconteurNode>& node, RobotRaconteur_LogLevel lvl,

                      RobotRaconteur_LogComponent component, int64_t ep, const boost::posix_time::ptime& time,

                      const std::string& source_file, uint32_t source_line, const std::string& thread_id);

    RRLogRecordStream(const RR_SHARED_PTR<RobotRaconteurNode>& node, RobotRaconteur_LogLevel lvl,

                      RobotRaconteur_LogComponent component, const std::string& component_name,

                      const std::string& component_object_id, int64_t ep, const std::string& service_path,

                      const std::string& member, const boost::posix_time::ptime& time, const std::string& source_file,

                      uint32_t source_line, const std::string& thread_id, const std::string& fiber_id);

    ~RRLogRecordStream();

    std::stringstream& Stream();


    static RR_INTRUSIVE_PTR<RRLogRecordStream> OpenRecordStream(

        RR_WEAK_PTR<RobotRaconteurNode> node, RobotRaconteur_LogLevel lvl, RobotRaconteur_LogComponent component,

        const std::string& component_name, const std::string& component_object_id, int64_t ep,

        MessageStringRef service_path, MessageStringRef member_name, const std::string& source_file,

        uint32_t source_line);

};


class ROBOTRACONTEUR_CORE_API LogRecordHandler

{

  public:

    virtual void HandleLogRecord(const RRLogRecord& record) = 0;

    virtual ~LogRecordHandler() {}

};


class ROBOTRACONTEUR_CORE_API FileLogRecordHandler : public LogRecordHandler

{

    std::ofstream file;


  public:

    void OpenFile(const std::string& filename, bool append = true);

    RR_OVIRTUAL void HandleLogRecord(const RRLogRecord& record) RR_OVERRIDE;

};


#define ROBOTRACONTEUR_LOG_EMPTY_NODE

#define ROBOTRACONTEUR_LOG_DEFAULT_NODE RobotRaconteur::RobotRaconteurNode::weak_sp()


#ifndef ROBOTRACONTEUR_DISABLE_LOGGING


// NOLINTBEGIN(bugprone-macro-parentheses)

#define ROBOTRACONTEUR_LOG(node, lvl, component, component_name, component_object_id, ep, service_path, member, args)  \

    {                                                                                                                  \

        boost::intrusive_ptr<RobotRaconteur::RRLogRecordStream> ____rr_log_record_stream____ =                         \

            RobotRaconteur::RRLogRecordStream::OpenRecordStream(                                                       \

                node, RobotRaconteur::RobotRaconteur_LogLevel_##lvl,                                                   \

                RobotRaconteur::RobotRaconteur_LogComponent_##component, component_name, component_object_id, ep,      \

                service_path, member, __FILE__, __LINE__);                                                             \

        if (____rr_log_record_stream____)                                                                              \

        {                                                                                                              \

            ____rr_log_record_stream____->Stream() << args;                                                            \

        }                                                                                                              \

    }


// NOLINTEND(bugprone-macro-parentheses)


// TODO: Implement throttling

#define ROBOTRACONTEUR_LOG_THROTTLE(node, lvl, component, component_name, component_object_id, ep, service_path,       \

                                    member, limit, args)                                                               \

    ROBOTRACONTEUR_LOG(node, lvl, component, component_name, component_object_id, ep, service_path, member, args)

#else

#define ROBOTRACONTEUR_LOG(node, lvl, component, component_name, component_object_id, ep, service_path, member, args)

#define ROBOTRACONTEUR_LOG_THROTTLE(node, lvl, component, component_name, component_object_id, ep, service_path,       \

                                    member, limit, args)

#endif


#define ROBOTRACONTEUR_LOG_FATAL(node, args) ROBOTRACONTEUR_LOG(node, Fatal, Default, "", "", -1, "", "", args)

#define ROBOTRACONTEUR_LOG_FATAL_DEFAULT(args)                                                                         \

    ROBOTRACONTEUR_LOG(ROBOTRACONTEUR_LOG_DEFAULT_NODE, Fatal, Default, "", "", -1, "", "", args)

#define ROBOTRACONTEUR_LOG_FATAL_COMPONENT(node, component, ep, args)                                                  \

    ROBOTRACONTEUR_LOG(node, Fatal, component, "", "", ep, "", "", args)

#define ROBOTRACONTEUR_LOG_FATAL_COMPONENT_PATH(node, component, ep, service_path, member, args)                       \

    ROBOTRACONTEUR_LOG(node, Fatal, component, "", "", ep, service_path, member, args)

#define ROBOTRACONTEUR_LOG_FATAL_COMPONENTNAME(node, component, component_name, component_object_id, ep, args)         \

    ROBOTRACONTEUR_LOG(node, Fatal, component, component_name, component_object_id, ep, "", "", args)

#define ROBOTRACONTEUR_LOG_FATAL_COMPONENTNAME_PATH(node, component, component_name, component_object_id, ep,          \

                                                    service_path, member, args)                                        \

    ROBOTRACONTEUR_LOG(node, Fatal, component, component_name, component_object_id, ep, service_path, member, args)

#define ROBOTRACONTEUR_LOG_FATAL_THROTTLE(node, component, ep, limit, args)                                            \

    ROBOTRACONTEUR_LOG_THROTTLE(node, Fatal, component, "", "", ep, "", "", limit, args)

#define ROBOTRACONTEUR_LOG_FATAL_THROTTLE_PATH(node, component, ep, service_path, member, limit, args)                 \

    ROBOTRACONTEUR_LOG_THROTTLE(node, Fatal, component, "", "", ep, service_path, member, limit, args)

#define ROBOTRACONTEUR_LOG_FATAL_THROTTLE_COMPONENTNAME_PATH(node, component, component_name, component_object_id, ep, \

                                                             service_path, member, limit, args)                        \

    ROBOTRACONTEUR_LOG_THROTTLE(node, Fatal, component, component_name, component_object_id, ep, service_path, member, \

                                limit, args)


#define ROBOTRACONTEUR_LOG_ERROR(node, args) ROBOTRACONTEUR_LOG(node, Error, Default, "", "", -1, "", "", args)

#define ROBOTRACONTEUR_LOG_ERROR_DEFAULT(args)                                                                         \

    ROBOTRACONTEUR_LOG(ROBOTRACONTEUR_LOG_DEFAULT_NODE, Error, Default, "", "", -1, "", "", args)

#define ROBOTRACONTEUR_LOG_ERROR_COMPONENT(node, component, ep, args)                                                  \

    ROBOTRACONTEUR_LOG(node, Error, component, "", "", ep, "", "", args)

#define ROBOTRACONTEUR_LOG_ERROR_COMPONENT_PATH(node, component, ep, service_path, member, args)                       \

    ROBOTRACONTEUR_LOG(node, Error, component, "", "", ep, service_path, member, args)

#define ROBOTRACONTEUR_LOG_ERROR_COMPONENTNAME(node, component, component_name, component_object_id, ep, args)         \

    ROBOTRACONTEUR_LOG(node, Error, component, component_name, component_object_id, ep, "", "", args)

#define ROBOTRACONTEUR_LOG_ERROR_COMPONENTNAME_PATH(node, component, component_name, component_object_id, ep,          \

                                                    service_path, member, args)                                        \

    ROBOTRACONTEUR_LOG(node, Error, component, component_name, component_object_id, ep, service_path, member, args)

#define ROBOTRACONTEUR_LOG_ERROR_THROTTLE(node, component, ep, limit, args)                                            \

    ROBOTRACONTEUR_LOG_THROTTLE(node, Error, component, "", "", ep, "", "", limit, args)

#define ROBOTRACONTEUR_LOG_ERROR_THROTTLE_PATH(node, component, ep, service_path, member, limit, args)                 \

    ROBOTRACONTEUR_LOG_THROTTLE(node, Error, component, "", "", ep, service_path, member, limit, args)

#define ROBOTRACONTEUR_LOG_ERROR_THROTTLE_COMPONENTNAME_PATH(node, component, component_name, component_object_id, ep, \

                                                             service_path, member, limit, args)                        \

    ROBOTRACONTEUR_LOG_THROTTLE(node, Error, component, component_name, component_object_id, ep, service_path, member, \

                                limit, args)


#define ROBOTRACONTEUR_LOG_WARNING(node, args) ROBOTRACONTEUR_LOG(node, Warning, Default, "", "", -1, "", "", args)

#define ROBOTRACONTEUR_LOG_WARNING_DEFAULT(args)                                                                       \

    ROBOTRACONTEUR_LOG(ROBOTRACONTEUR_LOG_DEFAULT_NODE, Warning, Default, "", "", -1, "", "", args)

#define ROBOTRACONTEUR_LOG_WARNING_COMPONENT(node, component, ep, args)                                                \

    ROBOTRACONTEUR_LOG(node, Warning, component, "", "", ep, "", "", args)

#define ROBOTRACONTEUR_LOG_WARNING_COMPONENT_PATH(node, component, ep, service_path, member, args)                     \

    ROBOTRACONTEUR_LOG(node, Warning, component, "", "", ep, service_path, member, args)

#define ROBOTRACONTEUR_LOG_WARNING_COMPONENTNAME(node, component, component_name, component_object_id, ep, args)       \

    ROBOTRACONTEUR_LOG(node, Warning, component, component_name, component_object_id, ep, "", "", args)

#define ROBOTRACONTEUR_LOG_WARNING_COMPONENTNAME_PATH(node, component, component_name, component_object_id, ep,        \

                                                      service_path, member, args)                                      \

    ROBOTRACONTEUR_LOG(node, Warning, component, component_name, component_object_id, ep, service_path, member, args)

#define ROBOTRACONTEUR_LOG_WARNING_THROTTLE(node, component, ep, limit, args)                                          \

    ROBOTRACONTEUR_LOG_THROTTLE(node, Warning, component, "", "", ep, "", "", limit, args)

#define ROBOTRACONTEUR_LOG_WARNING_THROTTLE_PATH(node, component, ep, service_path, member, limit, args)               \

    ROBOTRACONTEUR_LOG_THROTTLE(node, Warning, component, "", "", ep, service_path, member, limit, args)

#define ROBOTRACONTEUR_LOG_WARNING_THROTTLE_COMPONENTNAME_PATH(node, component, component_name, component_object_id,   \

                                                               ep, service_path, member, limit, args)                  \

    ROBOTRACONTEUR_LOG_THROTTLE(node, Warning, component, component_name, component_object_id, ep, service_path,       \

                                member, limit, args)


#define ROBOTRACONTEUR_LOG_INFO(node, args) ROBOTRACONTEUR_LOG(node, Info, Default, "", "", -1, "", "", args)

#define ROBOTRACONTEUR_LOG_INFO_DEFAULT(args)                                                                          \

    ROBOTRACONTEUR_LOG(ROBOTRACONTEUR_LOG_DEFAULT_NODE, Info, Default, "", "", -1, "", "", args)

#define ROBOTRACONTEUR_LOG_INFO_COMPONENT(node, component, ep, args)                                                   \

    ROBOTRACONTEUR_LOG(node, Info, component, "", "", ep, "", "", args)

#define ROBOTRACONTEUR_LOG_INFO_COMPONENT_PATH(node, component, ep, service_path, member, args)                        \

    ROBOTRACONTEUR_LOG(node, Info, component, "", "", ep, service_path, member, args)

#define ROBOTRACONTEUR_LOG_INFO_COMPONENTNAME(node, component, component_name, component_object_id, ep, args)          \

    ROBOTRACONTEUR_LOG(node, Info, component, component_name, component_object_id, ep, "", "", args)

#define ROBOTRACONTEUR_LOG_INFO_COMPONENTNAME_PATH(node, component, component_name, component_object_id, ep,           \

                                                   service_path, member, args)                                         \

    ROBOTRACONTEUR_LOG(node, Info, component, component_name, component_object_id, ep, service_path, member, args)

#define ROBOTRACONTEUR_LOG_INFO_THROTTLE(node, component, ep, limit, args)                                             \

    ROBOTRACONTEUR_LOG_THROTTLE(node, Info, component, "", "", ep, "", "", limit, args)

#define ROBOTRACONTEUR_LOG_INFO_THROTTLE_PATH(node, component, ep, service_path, member, limit, args)                  \

    ROBOTRACONTEUR_LOG_THROTTLE(node, Info, component, "", "", ep, service_path, member, limit, args)

#define ROBOTRACONTEUR_LOG_INFO_THROTTLE_COMPONENTNAME_PATH(node, component, component_name, component_object_id, ep,  \

                                                            service_path, member, limit, args)                         \

    ROBOTRACONTEUR_LOG_THROTTLE(node, Info, component, component_name, component_object_id, ep, service_path, member,  \

                                limit, args)


#define ROBOTRACONTEUR_LOG_DEBUG(node, args) ROBOTRACONTEUR_LOG(node, Debug, Default, "", "", -1, "", "", args)

#define ROBOTRACONTEUR_LOG_DEBUG_DEFAULT(args)                                                                         \

    ROBOTRACONTEUR_LOG(ROBOTRACONTEUR_LOG_DEFAULT_NODE, Debug, Default, "", "", -1, "", "", args)

#define ROBOTRACONTEUR_LOG_DEBUG_COMPONENT(node, component, ep, args)                                                  \

    ROBOTRACONTEUR_LOG(node, Debug, component, "", "", ep, "", "", args)

#define ROBOTRACONTEUR_LOG_DEBUG_COMPONENT_PATH(node, component, ep, service_path, member, args)                       \

    ROBOTRACONTEUR_LOG(node, Debug, component, "", "", ep, service_path, member, args)

#define ROBOTRACONTEUR_LOG_DEBUG_COMPONENTNAME(node, component, component_name, component_object_id, ep, args)         \

    ROBOTRACONTEUR_LOG(node, Debug, component, component_name, component_object_id, ep, "", "", args)

#define ROBOTRACONTEUR_LOG_DEBUG_COMPONENTNAME_PATH(node, component, component_name, component_object_id, ep,          \

                                                    service_path, member, args)                                        \

    ROBOTRACONTEUR_LOG(node, Debug, component, component_name, component_object_id, ep, service_path, member, args)

#define ROBOTRACONTEUR_LOG_DEBUG_THROTTLE(node, component, ep, limit, args)                                            \

    ROBOTRACONTEUR_LOG_THROTTLE(node, Debug, component, "", "", ep, "", "", limit, args)

#define ROBOTRACONTEUR_LOG_DEBUG_THROTTLE_PATH(node, component, ep, service_path, member, limit, args)                 \

    ROBOTRACONTEUR_LOG_THROTTLE(node, Debug, component, "", "", ep, service_path, member, limit, args)

#define ROBOTRACONTEUR_LOG_DEBUG_THROTTLE_COMPONENTNAME_PATH(node, component, component_name, component_object_id, ep, \

                                                             service_path, member, limit, args)                        \

    ROBOTRACONTEUR_LOG_THROTTLE(node, Debug, component, component_name, component_object_id, ep, service_path, member, \

                                limit, args)


#ifndef NDEBUG

#define ROBOTRACONTEUR_LOG_TRACE(node, args) ROBOTRACONTEUR_LOG(node, Trace, Default, "", "", -1, "", "", args)

#define ROBOTRACONTEUR_LOG_TRACE_DEFAULT(args)                                                                         \

    ROBOTRACONTEUR_LOG(ROBOTRACONTEUR_LOG_DEFAULT_NODE, Trace, Default, "", "", -1, "", "", args)

#define ROBOTRACONTEUR_LOG_TRACE_COMPONENT(node, component, ep, args)                                                  \

    ROBOTRACONTEUR_LOG(node, Trace, component, "", "", ep, "", "", args)

#define ROBOTRACONTEUR_LOG_TRACE_COMPONENT_PATH(node, component, ep, service_path, member, args)                       \

    ROBOTRACONTEUR_LOG(node, Trace, component, "", "", ep, service_path, member, args)

#define ROBOTRACONTEUR_LOG_TRACE_COMPONENTNAME(node, component, component_name, component_object_id, ep, args)         \

    ROBOTRACONTEUR_LOG(node, Trace, component, component_name, component_object_id, ep, "", "", args)

#define ROBOTRACONTEUR_LOG_TRACE_COMPONENTNAME_PATH(node, component, component_name, component_object_id, ep,          \

                                                    service_path, member, args)                                        \

    ROBOTRACONTEUR_LOG(node, Trace, component, component_name, component_object_id, ep, service_path, member, args)

#define ROBOTRACONTEUR_LOG_TRACE_THROTTLE(node, component, ep, limit, args)                                            \

    ROBOTRACONTEUR_LOG_THROTTLE(node, Trace, component, "", "", ep, "", "", limit, args)

#define ROBOTRACONTEUR_LOG_TRACE_THROTTLE_PATH(node, component, ep, service_path, member, limit, args)                 \

    ROBOTRACONTEUR_LOG_THROTTLE(node, Trace, component, "", "", ep, service_path, member, limit, args)

#define ROBOTRACONTEUR_LOG_TRACE_THROTTLE_COMPONENTNAME_PATH(node, component, component_name, component_object_id, ep, \

                                                             service_path, member, limit, args)                        \

    ROBOTRACONTEUR_LOG_THROTTLE(node, Trace, component, component_name, component_object_id, ep, service_path, member, \

                                limit, args)

#else

// Disable Trace log level in release builds for performance

#define ROBOTRACONTEUR_LOG_TRACE(node, args)

#define ROBOTRACONTEUR_LOG_TRACE_DEFAULT(args)

#define ROBOTRACONTEUR_LOG_TRACE_COMPONENT(node, component, ep, args)

#define ROBOTRACONTEUR_LOG_TRACE_COMPONENT_PATH(node, component, ep, service_path, member, args)

#define ROBOTRACONTEUR_LOG_TRACE_COMPONENTNAME(node, component, component_name, component_object_id, ep, args)

#define ROBOTRACONTEUR_LOG_TRACE_COMPONENTNAME_PATH(node, component, component_name, component_object_id, ep,          \

                                                    service_path, member, args)

#define ROBOTRACONTEUR_LOG_TRACE_THROTTLE(node, component, ep, limit, args)

#define ROBOTRACONTEUR_LOG_TRACE_THROTTLE_PATH(node, component, ep, service_path, member, limit, args)

#define ROBOTRACONTEUR_LOG_TRACE_THROTTLE_COMPONENTNAME_PATH(node, component, component_name, component_object_id, ep, \

                                                             service_path, member, limit, args)


#endif


#ifndef ROBOTRACONTEUR_NO_CXX11_TEMPLATE_ALIASES

using RRLogRecordStreamPtr = RR_INTRUSIVE_PTR<RRLogRecordStream>;

using RRLogRecordStreamConstPtr = RR_INTRUSIVE_PTR<const RRLogRecordStream>;

using LogRecordHandlerPtr = RR_SHARED_PTR<LogRecordHandler>;

using LogRecordHandlerConstPtr = RR_SHARED_PTR<const LogRecordHandler>;

using FileLogRecordHandlerPtr = RR_SHARED_PTR<FileLogRecordHandler>;

using FileLogRecordHandlerConstPtr = RR_SHARED_PTR<const FileLogRecordHandler>;

#endif


} // namespace RobotRaconteur

RobotRaconteur::LogRecordHandlerConstPtr
boost::shared_ptr< const LogRecordHandler > LogRecordHandlerConstPtr
Convenience alias for LogRecordHandler const shared_ptr.
Definition Logging.h:342

RobotRaconteur::FileLogRecordHandlerConstPtr
boost::shared_ptr< const FileLogRecordHandler > FileLogRecordHandlerConstPtr
Convenience alias for FileLogRecordHandler const shared_ptr.
Definition Logging.h:346

RobotRaconteur::LogRecordHandlerPtr
boost::shared_ptr< LogRecordHandler > LogRecordHandlerPtr
Convenience alias for LogRecordHandler shared_ptr.
Definition Logging.h:340

RobotRaconteur::RRLogRecord_Node_ToString
std::string RRLogRecord_Node_ToString(const RR_WEAK_PTR< RobotRaconteurNode > &node)
Convert a RobotRaconteurNode weak_ptr to a NodeID string. Returns "unknown" if could not resolve.

RobotRaconteur::RRLogRecord_Level_ToString
std::string RRLogRecord_Level_ToString(RobotRaconteur_LogLevel level)
Convert a RobotRaconteur_LogLevel code to a string.

RobotRaconteur::RRLogRecord_Component_ToString
std::string RRLogRecord_Component_ToString(RobotRaconteur_LogComponent component)
Convert a RobotRaconteur_LogComponent code to a string.

RobotRaconteur::FileLogRecordHandlerPtr
boost::shared_ptr< FileLogRecordHandler > FileLogRecordHandlerPtr
Convenience alias for FileLogRecordHandler shared_ptr.
Definition Logging.h:344

RobotRaconteurConfig.h

RobotRaconteurConstants.h

RobotRaconteur::RobotRaconteur_LogLevel
RobotRaconteur_LogLevel
Log level enum.
Definition RobotRaconteurConstants.h:608

RobotRaconteur::RobotRaconteur_LogComponent
RobotRaconteur_LogComponent
Log component enum.
Definition RobotRaconteurConstants.h:633

RobotRaconteur::FileLogRecordHandler
Log record handler that saves to a file.
Definition Logging.h:149

RobotRaconteur::FileLogRecordHandler::HandleLogRecord
RR_OVIRTUAL void HandleLogRecord(const RRLogRecord &record) RR_OVERRIDE
Function to accept log records from node.

RobotRaconteur::FileLogRecordHandler::OpenFile
void OpenFile(const std::string &filename, bool append=true)
Open a file to store log records.

RobotRaconteur::LogRecordHandler
Base class of log record handler.
Definition Logging.h:130

RobotRaconteur::LogRecordHandler::HandleLogRecord
virtual void HandleLogRecord(const RRLogRecord &record)=0
Function to accept log records from node.

RobotRaconteur::RRLogRecord
Robot Raconteur log record.
Definition Logging.h:49

RobotRaconteur::RRLogRecord::Endpoint
int64_t Endpoint
The source endpoint.
Definition Logging.h:62

RobotRaconteur::RRLogRecord::Node
RR_WEAK_PTR< RobotRaconteurNode > Node
The source node.
Definition Logging.h:52

RobotRaconteur::RRLogRecord::ComponentObjectID
std::string ComponentObjectID
The source component object ID.
Definition Logging.h:60

RobotRaconteur::RRLogRecord::SourceFile
std::string SourceFile
The sourcecode filename.
Definition Logging.h:72

RobotRaconteur::RRLogRecord::ComponentName
std::string ComponentName
The source component name.
Definition Logging.h:58

RobotRaconteur::RRLogRecord::Time
boost::posix_time::ptime Time
Time of logging event.
Definition Logging.h:70

RobotRaconteur::RRLogRecord::FiberID
std::string FiberID
The source coroutine fiber.
Definition Logging.h:78

RobotRaconteur::RRLogRecord::Component
RobotRaconteur_LogComponent Component
The source component.
Definition Logging.h:56

RobotRaconteur::RRLogRecord::Level
RobotRaconteur_LogLevel Level
The log level.
Definition Logging.h:54

RobotRaconteur::RRLogRecord::Member
std::string Member
The source member.
Definition Logging.h:66

RobotRaconteur::RRLogRecord::SourceLine
uint32_t SourceLine
The line within the sourcecode file.
Definition Logging.h:74

RobotRaconteur::RRLogRecord::Message
std::string Message
Human readable log message.
Definition Logging.h:68

RobotRaconteur::RRLogRecord::ThreadID
std::string ThreadID
The source thread.
Definition Logging.h:76

RobotRaconteur::RRLogRecord::ServicePath
std::string ServicePath
The service path of the source object.
Definition Logging.h:64

RobotRaconteur::RobotRaconteurNode
The central node implementation.
Definition RobotRaconteurNode.h:132