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