trace_config.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 <memory>
#include <mutex>

#include "trace_buffer.h"

namespace phosphor {

    // Forward declare
    class PHOSPHOR_API TraceLog;
    class PHOSPHOR_API TraceConfig;

    class TracingStoppedCallback {
    public:
        virtual ~TracingStoppedCallback() {}

        virtual void operator()(TraceLog&, std::lock_guard<TraceLog>&) = 0;

    };

    enum class BufferMode : char {
        custom = 0,
        fixed,
        ring,
    };

    PHOSPHOR_API
    std::ostream& operator<<(std::ostream& stream, const BufferMode mode);

    struct PHOSPHOR_API StringPtrDeleter {
        void operator()(const std::string* ptr);
    };

    using StringPtr = std::unique_ptr<const std::string, StringPtrDeleter>;

    StringPtr make_String(const std::string& str);

    class PHOSPHOR_API TraceLogConfig {
    public:
        TraceLogConfig() {
        }

        TraceLogConfig& setStartupTrace(const TraceConfig& _startup_trace);

        TraceLogConfig& clearStartupTrace();

        TraceConfig* getStartupTrace() const;

        TraceLogConfig& fromEnvironment();

    protected:
        std::unique_ptr<TraceConfig> startup_trace;
    };

    class PHOSPHOR_API TraceConfig {
    public:
        TraceConfig();

        ~TraceConfig();

        TraceConfig(BufferMode _buffer_mode, size_t _buffer_size);

        TraceConfig(trace_buffer_factory _buffer_factory, size_t _buffer_size);

        BufferMode getBufferMode() const;

        size_t getBufferSize() const;

        trace_buffer_factory getBufferFactory() const;

        TraceConfig& setStoppedCallback(
            std::shared_ptr<TracingStoppedCallback> _tracing_stopped_callback);

        TracingStoppedCallback* getStoppedCallback() const;

        TraceConfig& setStopTracingOnDestruct(bool _stop_tracing);

        bool getStopTracingOnDestruct() const;

        TraceConfig& setCategories(const std::vector<std::string>& enabled,
                                   const std::vector<std::string>& disabled);

        const std::vector<std::string>& getEnabledCategories() const;

        const std::vector<std::string>& getDisabledCategories() const;

        static TraceConfig fromString(const std::string& config);

        StringPtr toString() const;

    protected:
        static trace_buffer_factory modeToFactory(BufferMode mode);

        BufferMode buffer_mode = BufferMode::fixed;
        size_t buffer_size = 0;
        trace_buffer_factory buffer_factory = nullptr;
        std::shared_ptr<TracingStoppedCallback> tracing_stopped_callback;
        bool stop_tracing = false;

        std::vector<std::string> enabled_categories;
        std::vector<std::string> disabled_categories;
    };

}