trace_log.h

/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
 *     Copyright 2016 Couchbase, Inc
 *
 *   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.
 */

#pragma once

#include <atomic>
#include <memory>
#include <mutex>
#include <set>
#include <unordered_map>
#include <unordered_set>

#include "category_registry.h"
#include "chunk_lock.h"
#include "platform/thread.h"
#include "trace_buffer.h"
#include "trace_config.h"
#include "trace_context.h"
#include "trace_event.h"

namespace phosphor {

    class PHOSPHOR_API TraceLog {
    public:
        TraceLog(const TraceLogConfig& _config);

        TraceLog();

        ~TraceLog();

        void configure(const TraceLogConfig& _config);

        static TraceLog& getInstance();

        void start(const TraceConfig& _trace_config);

        void start(std::lock_guard<TraceLog>&,
                   const TraceConfig& _trace_config);

        void stop(bool shutdown = false);

        void stop(std::lock_guard<TraceLog>&, bool shutdown = false);

        template <typename T, typename U>
        void logEvent(const tracepoint_info* tpi,
                      TraceEvent::Type type,
                      T argA,
                      U argB) {
            if (!enabled) {
                return;
            }
            auto cl = getChunkTenant();
            if (cl) {
                cl.mutex()->chunk->addEvent() = TraceEvent(
                        tpi,
                        type,
                        platform::getCurrentThreadIDCached(),
                        {{TraceArgumentConversion<T>::asArgument(argA),
                          TraceArgumentConversion<U>::asArgument(argB)}},
                        {{TraceArgumentConversion<T>::getType(),
                          TraceArgumentConversion<U>::getType()}});
            }
        }

        template <typename T>
        void logEvent(const tracepoint_info* tpi,
                      TraceEvent::Type type,
                      T argA) {
            logEvent(tpi, type, argA, NoneType());
        }

        void logEvent(const tracepoint_info* tpi,
                      TraceEvent::Type type) {
            logEvent(tpi, type, NoneType(), NoneType());
        }

        const AtomicCategoryStatus& getCategoryStatus(
            const char* category_group);

        std::unique_ptr<TraceBuffer> getBuffer();

        std::unique_ptr<TraceBuffer> getBuffer(std::lock_guard<TraceLog>&);

        TraceContext getTraceContext();

        TraceContext getTraceContext(std::lock_guard<TraceLog>&);

        bool isEnabled() const;

        void registerThread(const std::string& thread_name = "");

        void deregisterThread();

        void lock() {
            mutex.lock();
        }

        void unlock() {
            mutex.unlock();
        }

        TraceConfig getTraceConfig() const;

        void getStats(StatsCallback& addStats) const;

    protected:

        std::unique_lock<ChunkTenant> getChunkTenant();

        bool replaceChunk(ChunkTenant& ct);

        void evictThreads(std::lock_guard<TraceLog>& lh);

        void clearDeregisteredThreads();

        void maybe_stop(size_t _generation);

        TraceConfig trace_config;

        std::atomic<bool> enabled;

        mutable std::mutex mutex;

        std::unique_ptr<TraceBuffer> buffer;

        std::atomic<size_t> generation;

        std::unordered_set<ChunkTenant*> registered_chunk_tenants;

        CategoryRegistry registry;

        std::unordered_map<uint64_t, std::string> thread_names;

        std::set<uint64_t> deregistered_threads;
    };
}