lib/stats/stats_mgr.h

Go to the documentation of this file.

// Copyright (C) 2015,2017 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef STATSMGR_H
#define STATSMGR_H

#include <stats/observation.h>
#include <stats/context.h>
#include <boost/noncopyable.hpp>

#include <map>
#include <string>
#include <vector>
#include <sstream>

namespace isc {
namespace stats {

class StatsMgr : public boost::noncopyable {
 public:

    static StatsMgr& instance();


    void setValue(const std::string& name, const int64_t value);

    void setValue(const std::string& name, const double value);

    void setValue(const std::string& name, const StatsDuration& value);

    void setValue(const std::string& name, const std::string& value);

    void addValue(const std::string& name, const int64_t value);

    void addValue(const std::string& name, const double value);

    void addValue(const std::string& name, const StatsDuration& value);

    void addValue(const std::string& name, const std::string& value);

    void setMaxSampleAge(const std::string& name, const StatsDuration& duration);

    void setMaxSampleCount(const std::string& name, uint32_t max_samples);



    bool reset(const std::string& name);

    bool del(const std::string& name);

    void resetAll();

    void removeAll();

    size_t count() const;

    isc::data::ConstElementPtr get(const std::string& name) const;

    isc::data::ConstElementPtr getAll() const;


    ObservationPtr getObservation(const std::string& name) const;

    template<typename Type>
    static std::string generateName(const std::string& context, Type index,
                             const std::string& stat_name) {
        std::stringstream name;
        name << context << "[" << index << "]." << stat_name;
        return (name.str());
    }


    static isc::data::ConstElementPtr
    statisticGetHandler(const std::string& name,
                        const isc::data::ConstElementPtr& params);

    static isc::data::ConstElementPtr
    statisticResetHandler(const std::string& name,
                          const isc::data::ConstElementPtr& params);

    static isc::data::ConstElementPtr
    statisticRemoveHandler(const std::string& name,
                           const isc::data::ConstElementPtr& params);

    static isc::data::ConstElementPtr
    statisticGetAllHandler(const std::string& name,
                           const isc::data::ConstElementPtr& params);

    static isc::data::ConstElementPtr
    statisticResetAllHandler(const std::string& name,
                             const isc::data::ConstElementPtr& params);

    static isc::data::ConstElementPtr
    statisticRemoveAllHandler(const std::string& name,
                              const isc::data::ConstElementPtr& params);


private:

    StatsMgr();


    template<typename DataType>
    void setValueInternal(const std::string& name, DataType value) {

        // If we want to log each observation, here would be the best place for it.
        ObservationPtr stat = getObservation(name);
        if (stat) {
            stat->setValue(value);
        } else {
            stat.reset(new Observation(name, value));
            addObservation(stat);
        }
    }


    template<typename DataType>
    void addValueInternal(const std::string& name, DataType value) {

        // If we want to log each observation, here would be the best place for it.
        ObservationPtr existing = getObservation(name);
        if (!existing) {
            // We tried to add to a non-existing statistic. We can recover from
            // that. Simply add the new incremental value as a new statistic and
            // we're done.
            setValue(name, value);
            return;
        } else {
            // Let's hope it is of correct type. If not, the underlying
            // addValue() method will throw.
            existing->addValue(value);
        }
    }


    void addObservation(const ObservationPtr& stat);


    bool deleteObservation(const std::string& name);

    static bool getStatName(const isc::data::ConstElementPtr& params,
                            std::string& name,
                            std::string& reason);

    // This is a global context. All statistics will initially be stored here.
    StatContextPtr global_;
};

};
};

#endif // STATS_MGR