Logger.h

Go to the documentation of this file.

/*
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *     http://aws.amazon.com/apache2.0/
 *
 * or in the "license" file accompanying this file. This file is distributed
 * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 */

#ifndef ALEXA_CLIENT_SDK_AVSCOMMON_UTILS_INCLUDE_AVSCOMMON_UTILS_LOGGER_LOGGER_H_
#define ALEXA_CLIENT_SDK_AVSCOMMON_UTILS_INCLUDE_AVSCOMMON_UTILS_LOGGER_LOGGER_H_

#include <atomic>
#include <chrono>
#include <mutex>
#include <sstream>
#include <vector>

#include <AVSCommon/Utils/Configuration/ConfigurationNode.h>

#include "AVSCommon/Utils/Logger/Level.h"
#include "AVSCommon/Utils/Logger/LogEntry.h"
#include "AVSCommon/Utils/Logger/LogLevelObserverInterface.h"
#include "AVSCommon/Utils/Logger/SinkObserverInterface.h"

#define ACSDK_STRINGIFY_INNER(expression) #expression

#define ACSDK_STRINGIFY(macro) ACSDK_STRINGIFY_INNER(macro)

#define ACSDK_CONCATENATE_INNER(lhs, rhs) lhs##rhs

#define ACSDK_CONCATENATE(lhs, rhs) ACSDK_CONCATENATE_INNER(lhs, rhs)

namespace alexaClientSDK {
namespace avsCommon {
namespace utils {
namespace logger {

class Logger {
public:
    Logger(Level level);

    virtual ~Logger() = default;

    virtual void setLevel(Level level);

    inline bool shouldLog(Level level) const;

    void log(Level level, const LogEntry& entry);

    void logAtExit(Level level, const LogEntry& entry);

    virtual void emit(
        Level level,
        std::chrono::system_clock::time_point time,
        const char* threadMoniker,
        const char* text);

    void addLogLevelObserver(LogLevelObserverInterface* observer);

    void removeLogLevelObserver(LogLevelObserverInterface* observer);

protected:
    void init(const configuration::ConfigurationNode configuration);

    std::atomic<Level> m_level;

private:
    bool initLogLevel(const configuration::ConfigurationNode configuration);

    void notifyObserversOnLogLevelChanged();

    std::vector<LogLevelObserverInterface*> m_observers;

    std::mutex m_observersMutex;
};

bool Logger::shouldLog(Level level) const {
    return level >= m_level;
}

#define ACSDK_GET_LOGGER_FUNCTION_NAME(type) ACSDK_CONCATENATE(ACSDK_CONCATENATE(get, type), Logger)

std::shared_ptr<Logger> getConsoleLogger();

}  // namespace logger
}  // namespace utils
}  // namespace avsCommon
}  // namespace alexaClientSDK

#ifndef ACSDK_LOG_MODULE
#define ACSDK_LOG_MODULE ConsoleLogger
#endif  // ACSDK_LOG_MODULE

#include "AVSCommon/Utils/Logger/ModuleLogger.h"

namespace alexaClientSDK {
namespace avsCommon {
namespace utils {
namespace logger {

#define ACSDK_GET_LOGGER_FUNCTION ACSDK_GET_LOGGER_FUNCTION_NAME(ACSDK_LOG_MODULE)

inline std::shared_ptr<Logger> ACSDK_GET_LOGGER_FUNCTION() {
    static std::shared_ptr<ModuleLogger> moduleLogger =
        std::make_shared<ModuleLogger>(ACSDK_STRINGIFY(ACSDK_LOG_MODULE));
    return moduleLogger;
}

}  // namespace logger
}  // namespace utils
}  // namespace avsCommon
}  // namespace alexaClientSDK

#ifdef ACSDK_LOG_ENABLED
#define ACSDK_LOG(level, entry)                                                                      \
    do {                                                                                             \
        auto loggerInstance = alexaClientSDK::avsCommon::utils::logger::ACSDK_GET_LOGGER_FUNCTION(); \
        if (loggerInstance->shouldLog(level)) {                                                      \
            loggerInstance->log(level, entry);                                                       \
        }                                                                                            \
    } while (false)
#else  // ACSDK_LOG_ENABLED
#define ACSDK_LOG(level, entry) \
    do {                        \
        (void)sizeof(level);    \
        (void)sizeof(entry);    \
    } while (false)
#endif  // ACSDK_LOG_ENABLED

#ifdef ACSDK_DEBUG_LOG_ENABLED
#define ACSDK_DEBUG_LOG(level, entry) ACSDK_LOG((level), (entry))
#else  // ACSDK_DEBUG_LOG_ENABLED
#define ACSDK_DEBUG_LOG(level, entry) \
    do {                              \
        (void)sizeof(level);          \
        (void)sizeof(entry);          \
    } while (false)
#endif  // ACSDK_DEBUG_LOG_ENABLED

#define ACSDK_DEBUG9(entry) ACSDK_DEBUG_LOG(alexaClientSDK::avsCommon::utils::logger::Level::DEBUG9, entry)

#define ACSDK_DEBUG8(entry) ACSDK_DEBUG_LOG(alexaClientSDK::avsCommon::utils::logger::Level::DEBUG8, entry)

#define ACSDK_DEBUG7(entry) ACSDK_DEBUG_LOG(alexaClientSDK::avsCommon::utils::logger::Level::DEBUG7, entry)

#define ACSDK_DEBUG6(entry) ACSDK_DEBUG_LOG(alexaClientSDK::avsCommon::utils::logger::Level::DEBUG6, entry)

#define ACSDK_DEBUG5(entry) ACSDK_DEBUG_LOG(alexaClientSDK::avsCommon::utils::logger::Level::DEBUG5, entry)

#define ACSDK_DEBUG4(entry) ACSDK_DEBUG_LOG(alexaClientSDK::avsCommon::utils::logger::Level::DEBUG4, entry)

#define ACSDK_DEBUG3(entry) ACSDK_DEBUG_LOG(alexaClientSDK::avsCommon::utils::logger::Level::DEBUG3, entry)

#define ACSDK_DEBUG2(entry) ACSDK_DEBUG_LOG(alexaClientSDK::avsCommon::utils::logger::Level::DEBUG2, entry)

#define ACSDK_DEBUG1(entry) ACSDK_DEBUG_LOG(alexaClientSDK::avsCommon::utils::logger::Level::DEBUG1, entry)

#define ACSDK_DEBUG0(entry) ACSDK_DEBUG_LOG(alexaClientSDK::avsCommon::utils::logger::Level::DEBUG0, entry)

#define ACSDK_DEBUG(entry) ACSDK_DEBUG_LOG(alexaClientSDK::avsCommon::utils::logger::Level::DEBUG0, entry)

#define ACSDK_INFO(entry) ACSDK_LOG(alexaClientSDK::avsCommon::utils::logger::Level::INFO, entry)

#define ACSDK_WARN(entry) ACSDK_LOG(alexaClientSDK::avsCommon::utils::logger::Level::WARN, entry)

#define ACSDK_ERROR(entry) ACSDK_LOG(alexaClientSDK::avsCommon::utils::logger::Level::ERROR, entry)

#define ACSDK_CRITICAL(entry) ACSDK_LOG(alexaClientSDK::avsCommon::utils::logger::Level::CRITICAL, entry)

#ifndef ACSDK_LOGS_KEEP_FUNC_MACRO
// In older Android releases __func__ is redefined as __PRETTY_FUNCTION__ making log messages difficult to read and
// analyse. We undefine this macro if it is defined. See Logger.cmake for details on how to keep the macro intact.
#undef __func__
#endif  // ACSDK_LOGS_KEEP_FUNC_MACRO

#endif  // ALEXA_CLIENT_SDK_AVSCOMMON_UTILS_INCLUDE_AVSCOMMON_UTILS_LOGGER_LOGGER_H_