NET_UniversalLogNetworkingSource.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        NET_UniversalLogNetworkingSource.h
 *
 * COMMENTS:
 *
 */

#ifndef __NET_UNIVERSALLOGNETWORKINGSOURCE_H__
#define __NET_UNIVERSALLOGNETWORKINGSOURCE_H__

#include "NET_API.h"

#include <UT/UT_UniversalLogEntry.h>
#include <UT/UT_UniversalLogSource.h>

NET_API const UT_StringHolder& NETsourceName();
NET_API void NETsendLogEntry(const UT_UniversalLogEntry& entry);

/// Both logs and keeps track of logged entries. This is mostly useful if you
/// need to keep track of all logged messages. As an example, HTTP api requests
/// need to be logged but also collected so they can be sent back to the client.
class NET_API NET_LogManager
{
public:
    NET_LogManager() :
        myTrackLogs(true)
    {}

    template <typename... Args>
    void logMessage(
            const UT_StringHolder& source_name,
            const char* fmt,
            Args&&... args)
    {
        UT_StringHolder msg;
        msg.format(fmt, std::forward<Args>(args)...);
        logEntry(UT_UniversalLogEntry(source_name, msg, "", UT_ERROR_MESSAGE));
    }
    template <typename... Args>
    void logPrompt(
            const UT_StringHolder& source_name,
            const char* fmt,
            Args&&... args)
    {
        UT_StringHolder msg;
        msg.format(fmt, std::forward<Args>(args)...);
        logEntry(UT_UniversalLogEntry(source_name, msg, "", UT_ERROR_PROMPT));
    }
    template <typename... Args>
    void logWarning(
            const UT_StringHolder& source_name,
            const char* fmt,
            Args&&... args)
    {
        UT_StringHolder msg;
        msg.format(fmt, std::forward<Args>(args)...);
        logEntry(UT_UniversalLogEntry(source_name, msg, "", UT_ERROR_WARNING));
    }
    template <typename... Args>
    void logError(
            const UT_StringHolder& source_name,
            const char* fmt,
            Args&&... args)
    {
        UT_StringHolder msg;
        msg.format(fmt, std::forward<Args>(args)...);
        logEntry(UT_UniversalLogEntry(source_name, msg, "", UT_ERROR_ABORT));
    }
    template <typename... Args>
    void logFatal(
            const UT_StringHolder& source_name,
            const char* fmt,
            Args&&... args)
    {
        UT_StringHolder msg;
        msg.format(fmt, std::forward<Args>(args)...);
        logEntry(UT_UniversalLogEntry(source_name, msg, "", UT_ERROR_FATAL));
    }
    void logEntry(const UT_UniversalLogEntry& entry)
    {
        NETsendLogEntry(entry);

        if (!myTrackLogs)
            return;
        myLogs.emplace_back(entry);
    }

    const UT_UniversalLogEntryArray& logs() const { return myLogs; }
    void clear() { myLogs.clear(); }

    void setTrackLogs(bool track) { myTrackLogs = track; }
    SYS_NO_DISCARD_RESULT bool isTrackingLogs() const { return myTrackLogs; }

    void generateMessage(
            UT_StringHolder& message,
            UT_ErrorSeverity sev = UT_ErrorSeverity::UT_ERROR_NONE);

    SYS_NO_DISCARD_RESULT bool isEmpty() const
    {
        return myLogs.isEmpty();
    }
private:
    bool myTrackLogs;
    UT_UniversalLogEntryArray myLogs;
};

// -----------------------------------------------------------------------------
// Adds logs to the provided log manager.
// -----------------------------------------------------------------------------

template <typename... Args>
void
NETlogMessage(
        NET_LogManager& mgr,
        const UT_StringHolder& context,
        const char* fmt,
        Args&&... args)
{
    UT_StringHolder msg;
    msg.format(fmt, std::forward<Args>(args)...);
    mgr.logEntry(UT_UniversalLogEntry(
            NETsourceName(), msg, context, UT_ERROR_MESSAGE));
}
template <typename... Args>
void
NETlogPrompt(
        NET_LogManager& mgr,
        const UT_StringHolder& context,
        const char* fmt,
        Args&&... args)
{
    UT_StringHolder msg;
    msg.format(fmt, std::forward<Args>(args)...);
    mgr.logEntry(UT_UniversalLogEntry(
            NETsourceName(), msg, context, UT_ERROR_PROMPT));
}

template <typename... Args>
void
NETlogWarning(
        NET_LogManager& mgr,
        const UT_StringHolder& context,
        const char* fmt,
        Args&&... args)
{
    UT_StringHolder msg;
    msg.format(fmt, std::forward<Args>(args)...);
    mgr.logEntry(UT_UniversalLogEntry(
            NETsourceName(), msg, context, UT_ERROR_WARNING));
}

template <typename... Args>
void
NETlogError(
        NET_LogManager& mgr,
        const UT_StringHolder& context,
        const char* fmt,
        Args&&... args)
{
    UT_StringHolder msg;
    msg.format(fmt, std::forward<Args>(args)...);
    mgr.logEntry(UT_UniversalLogEntry(
            NETsourceName(), msg, context, UT_ERROR_ABORT));
}

template <typename... Args>
void
NETlogFatal(
        NET_LogManager& mgr,
        const UT_StringHolder& context,
        const char* fmt,
        Args&&... args)
{
    UT_StringHolder msg;
    msg.format(fmt, std::forward<Args>(args)...);
    mgr.logEntry(UT_UniversalLogEntry(
            NETsourceName(), msg, context, UT_ERROR_FATAL));
}

// -----------------------------------------------------------------------------
// Adds errors to general error manager.
// -----------------------------------------------------------------------------

template <typename... Args>
void
NETlogMessage(const UT_StringHolder& context, const char* fmt, Args&&... args)
{
    UT_StringHolder msg;
    msg.format(fmt, std::forward<Args>(args)...);
    NETsendLogEntry(UT_UniversalLogEntry(
            NETsourceName(), msg, context, UT_ERROR_MESSAGE));
}
template <typename... Args>
void
NETlogPrompt(const UT_StringHolder& context, const char* fmt, Args&&... args)
{
    UT_StringHolder msg;
    msg.format(fmt, std::forward<Args>(args)...);
    NETsendLogEntry(UT_UniversalLogEntry(
            NETsourceName(), msg, context, UT_ERROR_PROMPT));
}

template <typename... Args>
void
NETlogWarning(const UT_StringHolder& context, const char* fmt, Args&&... args)
{
    UT_StringHolder msg;
    msg.format(fmt, std::forward<Args>(args)...);
    NETsendLogEntry(UT_UniversalLogEntry(
            NETsourceName(), msg, context, UT_ERROR_WARNING));
}

template <typename... Args>
void
NETlogError(const UT_StringHolder& context, const char* fmt, Args&&... args)
{
    UT_StringHolder msg;
    msg.format(fmt, std::forward<Args>(args)...);
    NETsendLogEntry(UT_UniversalLogEntry(
            NETsourceName(), msg, context, UT_ERROR_ABORT));
}

template <typename... Args>
void
NETlogFatal(const UT_StringHolder& context, const char* fmt, Args&&... args)
{
    UT_StringHolder msg;
    msg.format(fmt, std::forward<Args>(args)...);
    NETsendLogEntry(UT_UniversalLogEntry(
            NETsourceName(), msg, context, UT_ERROR_FATAL));
}

#endif // __NET_UNIVERSALLOGNETWORKINGSOURCE_H__