lib/stats/stats_mgr.h

Go to the documentation of this file.

// Copyright (C) 2015-2023 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 <util/bigints.h>
 
#include <boost/noncopyable.hpp>
#include <boost/scoped_ptr.hpp>
 
#include <map>
#include <mutex>
#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 isc::util::int128_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 isc::util::int128_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);
 
    bool setMaxSampleAge(const std::string& name, const StatsDuration& duration);
 
    bool setMaxSampleCount(const std::string& name, uint32_t max_samples);
 
    void setMaxSampleAgeAll(const StatsDuration& duration);
 
    void setMaxSampleCountAll(uint32_t max_samples);
 
    void setMaxSampleAgeDefault(const StatsDuration& duration);
 
    void setMaxSampleCountDefault(uint32_t max_samples);
 
    const StatsDuration& getMaxSampleAgeDefault() const;
 
    uint32_t getMaxSampleCountDefault() const;
 
 
 
    bool reset(const std::string& name);
 
    bool del(const std::string& name);
 
    void resetAll();
 
    void removeAll();
 
    size_t getSize(const std::string& name) const;
 
    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;
 
    ObservationPtr getObservationInternal(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
    statisticSetMaxSampleAgeHandler(const std::string& name,
                                    const isc::data::ConstElementPtr& params);
 
    static isc::data::ConstElementPtr
    statisticSetMaxSampleCountHandler(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);
 
    isc::data::ConstElementPtr
    statisticSetMaxSampleAgeAllHandler(const isc::data::ConstElementPtr& params);
 
    isc::data::ConstElementPtr
    statisticSetMaxSampleCountAllHandler(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 = getObservationInternal(name);
        if (stat) {
            stat->setValue(value);
        } else {
            stat.reset(new Observation(name, value));
            addObservationInternal(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 = getObservationInternal(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.
            setValueInternal(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);
 
 
    void addObservationInternal(const ObservationPtr& stat);
 
 
    bool deleteObservation(const std::string& name);
 
 
    bool deleteObservationInternal(const std::string& name);
 
 
    bool setMaxSampleAgeInternal(const std::string& name, const StatsDuration& duration);
 
 
    bool setMaxSampleCountInternal(const std::string& name, uint32_t max_samples);
 
 
    void setMaxSampleAgeAllInternal(const StatsDuration& duration);
 
 
    void setMaxSampleCountAllInternal(uint32_t max_samples);
 
 
    void setMaxSampleAgeDefaultInternal(const StatsDuration& duration);
 
    void setMaxSampleCountDefaultInternal(uint32_t max_samples);
 
 
    const StatsDuration& getMaxSampleAgeDefaultInternal() const;
 
    uint32_t getMaxSampleCountDefaultInternal() const;
 
 
    bool resetInternal(const std::string& name);
 
 
    bool delInternal(const std::string& name);
 
 
    void resetAllInternal();
 
 
    void removeAllInternal();
 
 
    size_t getSizeInternal(const std::string& name) const;
 
 
    size_t countInternal() const;
 
 
    isc::data::ConstElementPtr getInternal(const std::string& name) const;
 
 
    isc::data::ConstElementPtr getAllInternal() const;
 
 
    static bool getStatName(const isc::data::ConstElementPtr& params,
                            std::string& name,
                            std::string& reason);
 
 
    static bool getStatDuration(const isc::data::ConstElementPtr& params,
                                StatsDuration& duration,
                                std::string& reason);
 
 
    static bool getStatMaxSamples(const isc::data::ConstElementPtr& params,
                                  uint32_t& max_samples,
                                  std::string& reason);
 
    StatContextPtr global_;
 
    const boost::scoped_ptr<std::mutex> mutex_;
};
 
}  // namespace stats
}  // namespace isc
 
#endif // STATS_MGR