lib/stats/stats_mgr.h

Go to the documentation of this file.

// Copyright (C) 2015-2025 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;

    isc::data::ConstElementPtr getAllGlobal() 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
    statisticGlobalGetAllHandler(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;

    isc::data::ConstElementPtr getAllGlobalInternal() 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