observation.h

Go to the documentation of this file.

// Copyright (C) 2015-2026 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 OBSERVATION_H
#define OBSERVATION_H
 
#include <cc/data.h>
#include <exceptions/exceptions.h>
#include <util/bigints.h>
 
#include <chrono>
#include <cstdint>
#include <list>
 
#include <boost/shared_ptr.hpp>
 
namespace isc {
namespace stats {

class InvalidStatType : public Exception {
public:
    InvalidStatType(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};

typedef std::chrono::system_clock SampleClock;

typedef std::chrono::system_clock::duration StatsDuration;

inline long toSeconds(const StatsDuration& dur) {
    return ((std::chrono::duration_cast<std::chrono::seconds>(dur)).count());
}


typedef std::pair<int64_t, SampleClock::time_point> IntegerSample;

typedef std::pair<isc::util::int128_t, SampleClock::time_point> BigIntegerSample;

typedef std::pair<double, SampleClock::time_point> FloatSample;

typedef std::pair<StatsDuration, SampleClock::time_point> DurationSample;

typedef std::pair<std::string, SampleClock::time_point> StringSample;


class Observation {
public:

    enum Type : uint16_t {
        STAT_INTEGER,       
        STAT_BIG_INTEGER,   
        STAT_FLOAT,         
        STAT_DURATION,      
        STAT_STRING         
    };

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

    Observation(const std::string& name, const isc::util::int128_t& value);

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

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

    Observation(const std::string& name, const std::string& value);

    void setMaxSampleAge(const StatsDuration& duration);

    void setMaxSampleCount(uint32_t max_samples);

    static void setMaxSampleAgeDefault(const StatsDuration& duration);

    static void setMaxSampleCountDefault(uint32_t max_samples);

    static const StatsDuration& getMaxSampleAgeDefault();

    static uint32_t getMaxSampleCountDefault();


    void setValue(const int64_t value);

    void setValue(const isc::util::int128_t& value);

    void setValue(const double value);

    void setValue(const StatsDuration& value);

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

    void addValue(const int64_t value);

    void addValue(const isc::util::int128_t& value);

    void addValue(const double value);

    void addValue(const StatsDuration& value);

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

    size_t getSize() const;

    std::pair<bool, StatsDuration> getMaxSampleAge() const;

    std::pair<bool, uint32_t> getMaxSampleCount() const;

    void reset();

    Type getType() const {
        return (type_);
    }

    IntegerSample getInteger() const;

    BigIntegerSample getBigInteger() const;

    FloatSample getFloat() const;

    DurationSample getDuration() const;

    StringSample getString() const;

    std::list<IntegerSample> getIntegers() const;

    std::list<BigIntegerSample> getBigIntegers() const;

    std::list<FloatSample> getFloats() const;

    std::list<DurationSample> getDurations() const;

    std::list<StringSample> getStrings() const;

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

    static std::string typeToText(Type type);

    std::string getName() const {
        return (name_);
    }
 
private:

    template<typename StorageType>
    size_t getSizeInternal(StorageType& storage, Type exp_type) const;

    template<typename SampleType, typename StorageType>
    void setValueInternal(SampleType value, StorageType& storage,
                          Type exp_type);

    template<typename SampleType, typename Storage>
    SampleType getValueInternal(Storage& storage, Type exp_type) const;

    template<typename SampleType, typename Storage>
    std::list<SampleType> getValuesInternal(Storage& storage,
                                            Type exp_type) const;

    template<typename StorageType>
    void setMaxSampleAgeInternal(StorageType& storage,
                                 const StatsDuration& duration, Type exp_type);

    template<typename StorageType>
    void setMaxSampleCountInternal(StorageType& storage,
                                   uint32_t max_samples, Type exp_type);

    std::string name_;

    Type type_;

    std::pair<bool, uint32_t> max_sample_count_;

    static std::pair<bool, uint32_t> default_max_sample_count_;

    std::pair<bool, StatsDuration> max_sample_age_;

    static std::pair<bool, StatsDuration> default_max_sample_age_;


    std::list<IntegerSample> integer_samples_;

    std::list<BigIntegerSample> big_integer_samples_;

    std::list<FloatSample> float_samples_;

    std::list<DurationSample> duration_samples_;

    std::list<StringSample> string_samples_;
};

typedef boost::shared_ptr<Observation> ObservationPtr;
 
}
}
 
#endif // OBSERVATION_H