common/netd/libnetdutils/include/netdutils/Log.h

/*
 * Copyright (C) 2018 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License 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 NETUTILS_LOG_H
#define NETUTILS_LOG_H

#include <chrono>
#include <deque>
#include <shared_mutex>
#include <string>
#include <type_traits>
#include <vector>

#include <android-base/stringprintf.h>
#include <android-base/thread_annotations.h>

#include <netdutils/Status.h>

namespace android {
namespace netdutils {

class LogEntry {
  public:
    LogEntry() = default;
    LogEntry(const LogEntry&) = default;
    LogEntry(LogEntry&&) = default;
    ~LogEntry() = default;
    LogEntry& operator=(const LogEntry&) = default;
    LogEntry& operator=(LogEntry&&) = default;

    std::string toString() const;

    ///
    // Helper methods that make it easy to build up a LogEntry message.
    // If performance becomes a factor the implementations could be inlined.
    ///
    LogEntry& message(const std::string& message);

    // For calling with __FUNCTION__.
    LogEntry& function(const std::string& function_name);
    // For calling with __PRETTY_FUNCTION__.
    LogEntry& prettyFunction(const std::string& pretty_function);

    // Convenience methods for each of the common types of function arguments.
    LogEntry& arg(const std::string& val);
    // Intended for binary buffers, formats as hex
    LogEntry& arg(const std::vector<uint8_t>& val);
    LogEntry& arg(const std::vector<int32_t>& val);
    LogEntry& arg(const std::vector<std::string>& val);
    template <typename IntT, typename = std::enable_if_t<std::is_arithmetic_v<IntT>>>
    LogEntry& arg(IntT val) {
        mArgs.push_back(std::to_string(val));
        return *this;
    }
    // Not using a plain overload here to avoid the implicit conversion from
    // any pointer to bool, which causes string literals to print as 'true'.
    template <>
    LogEntry& arg<>(bool val);

    template <typename... Args>
    LogEntry& args(const Args&... a) {
        // Cleverness ahead: we throw away the initializer_list filled with
        // zeroes, all we care about is calling arg() for each argument.
        (void) std::initializer_list<int>{(arg(a), 0)...};
        return *this;
    }

    // Some things can return more than one value, or have multiple output
    // parameters, so each of these adds to the mReturns vector.
    LogEntry& returns(const std::string& rval);
    LogEntry& returns(const Status& status);
    LogEntry& returns(bool rval);
    template <class T>
    LogEntry& returns(T val) {
        mReturns.push_back(std::to_string(val));
        return *this;
    }

    LogEntry& withUid(uid_t uid);

    // Append the duration computed since the creation of this instance.
    LogEntry& withAutomaticDuration();
    // Append the string-ified duration computed by some other means.
    LogEntry& withDuration(const std::string& duration);

  private:
    std::chrono::steady_clock::time_point mStart = std::chrono::steady_clock::now();
    std::string mMsg{};
    std::string mFunc{};
    std::vector<std::string> mArgs{};
    std::vector<std::string> mReturns{};
    std::string mUid{};
    std::string mDuration{};
};

class Log {
  public:
    Log() = delete;
    Log(const std::string& tag) : Log(tag, MAX_ENTRIES) {}
    Log(const std::string& tag, size_t maxEntries) : mTag(tag), mMaxEntries(maxEntries) {}
    Log(const Log&) = delete;
    Log(Log&&) = delete;
    ~Log();
    Log& operator=(const Log&) = delete;
    Log& operator=(Log&&) = delete;

    LogEntry newEntry() const { return LogEntry(); }

    // Record a log entry in internal storage only.
    void log(const std::string& entry) { record(Level::LOG, entry); }
    template <size_t n>
    void log(const char entry[n]) { log(std::string(entry)); }
    void log(const LogEntry& entry) { log(entry.toString()); }
    void log(const char* fmt, ...) __attribute__((__format__(__printf__, 2, 3))) {
        using ::android::base::StringAppendV;
        std::string result;
        va_list ap;
        va_start(ap, fmt);
        StringAppendV(&result, fmt, ap);
        va_end(ap);
        log(result);
    }

    // Record a log entry in internal storage and to ALOGI as well.
    void info(const std::string& entry) { record(Level::INFO, entry); }
    template <size_t n>
    void info(const char entry[n]) { info(std::string(entry)); }
    void info(const LogEntry& entry) { info(entry.toString()); }
    void info(const char* fmt, ...) __attribute__((__format__(__printf__, 2, 3))) {
        using ::android::base::StringAppendV;
        std::string result;
        va_list ap;
        va_start(ap, fmt);
        StringAppendV(&result, fmt, ap);
        va_end(ap);
        info(result);
    }

    // Record a log entry in internal storage and to ALOGW as well.
    void warn(const std::string& entry) { record(Level::WARN, entry); }
    template <size_t n>
    void warn(const char entry[n]) { warn(std::string(entry)); }
    void warn(const LogEntry& entry) { warn(entry.toString()); }
    void warn(const char* fmt, ...) __attribute__((__format__(__printf__, 2, 3))) {
        using ::android::base::StringAppendV;
        std::string result;
        va_list ap;
        va_start(ap, fmt);
        StringAppendV(&result, fmt, ap);
        va_end(ap);
        warn(result);
    }

    // Record a log entry in internal storage and to ALOGE as well.
    void error(const std::string& entry) { record(Level::ERROR, entry); }
    template <size_t n>
    void error(const char entry[n]) { error(std::string(entry)); }
    void error(const LogEntry& entry) { error(entry.toString()); }
    void error(const char* fmt, ...) __attribute__((__format__(__printf__, 2, 3))) {
        using ::android::base::StringAppendV;
        std::string result;
        va_list ap;
        va_start(ap, fmt);
        StringAppendV(&result, fmt, ap);
        va_end(ap);
        error(result);
    }

    // Iterates over every entry in the log in chronological order. Operates
    // on a copy of the log entries, and so perEntryFn may itself call one of
    // the logging functions if needed.
    void forEachEntry(const std::function<void(const std::string&)>& perEntryFn) const;

  private:
    static constexpr const size_t MAX_ENTRIES = 750U;
    const std::string mTag;
    const size_t mMaxEntries;

    // The LOG level adds an entry to mEntries but does not output the message
    // to the system log. All other levels append to mEntries and output to the
    // the system log.
    enum class Level {
        LOG,
        INFO,
        WARN,
        ERROR,
    };

    void record(Level lvl, const std::string& entry);

    mutable std::shared_mutex mLock;
    std::deque<const std::string> mEntries;  // GUARDED_BY(mLock), when supported
};

}  // namespace netdutils
}  // namespace android

#endif /* NETUTILS_LOG_H */