monitored_duration.h

Go to the documentation of this file.

// Copyright (C) 2024 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 _MONITORED_DURATION_H
#define _MONITORED_DURATION_H
 
#include <dhcp/pkt.h>
#include <dhcpsrv/subnet_id.h>
 
#include <boost/date_time/posix_time/posix_time.hpp>
 
namespace isc {
namespace perfmon {
 
typedef boost::posix_time::ptime Timestamp;
typedef boost::posix_time::time_duration Duration;
 
class DurationDataInterval {
public:
    static const Duration& ZERO_DURATION() {
        static Duration duration(boost::posix_time::microseconds(0));
        return (duration);
    }
 
    explicit DurationDataInterval(const Timestamp& start_time = dhcp::PktEvent::now());
 
    ~DurationDataInterval() = default;
 
    void addDuration(const Duration& duration);
 
    const Timestamp& getStartTime() const {
        return (start_time_);
    }
 
    void setStartTime(const Timestamp& start_time) {
        start_time_ = start_time;
    }
 
    uint64_t getOccurrences() const {
        return (occurrences_);
    };
 
    Duration getMinDuration() const {
        return (min_duration_);
    }
 
    Duration getMaxDuration() const {
        return (max_duration_);
    }
 
    Duration getTotalDuration() const {
        return (total_duration_);
    }
 
    Duration getAverageDuration() const;
 
    bool operator==(const DurationDataInterval& other) const;
 
private:
    Timestamp start_time_;
 
    uint64_t occurrences_;
 
    Duration min_duration_;
 
    Duration max_duration_;
 
    Duration total_duration_;
};
 
typedef boost::shared_ptr<DurationDataInterval> DurationDataIntervalPtr;
 
class DurationKey {
public:
    DurationKey(uint16_t family, uint8_t query_type, uint8_t response_type,
                const std::string& start_event_label, const std::string& stop_event_label,
                dhcp::SubnetID subnet_id);
 
    virtual ~DurationKey() = default;
 
    uint16_t getFamily() {
        return (family_);
    }
 
    uint8_t getQueryType() const {
        return (query_type_);
    }
 
    uint8_t getResponseType() const {
        return (response_type_);
    };
 
    std::string getStartEventLabel() const {
        return (start_event_label_);
    }
 
    std::string getStopEventLabel() const {
        return (stop_event_label_);
    }
 
    dhcp::SubnetID getSubnetId() const {
        return (subnet_id_);
    }
 
    void setSubnetId(dhcp::SubnetID subnet_id) {
        subnet_id_ = subnet_id;
    }
 
    static std::string getMessageTypeLabel(uint16_t family, uint16_t msg_type);
 
    std::string getLabel() const;
 
    std::string getStatName(const std::string& value_name) const;
 
    static void validateMessagePair(uint16_t family, uint8_t query_type, uint8_t response_type);
 
    bool operator==(const DurationKey& other) const;
 
    bool operator!=(const DurationKey& other) const;
 
    bool operator<(const DurationKey& other) const;
 
protected:
    uint16_t family_;
 
    uint8_t query_type_;
 
    uint8_t response_type_;
 
    std::string start_event_label_;
 
    std::string stop_event_label_;
 
    isc::dhcp::SubnetID subnet_id_;
};
 
std::ostream&
operator<<(std::ostream& os, const DurationKey& key);
 
typedef boost::shared_ptr<DurationKey> DurationKeyPtr;
 
class MonitoredDuration : public DurationKey {
public:
    MonitoredDuration(uint16_t family, uint8_t query_type, uint8_t response_type,
                      const std::string& start_event_label, const std::string& stop_event_label,
                      dhcp::SubnetID subnet_id, const Duration& interval_duration);
 
    MonitoredDuration(const DurationKey& key, const Duration& interval_duration);
 
    MonitoredDuration(const MonitoredDuration& rhs);
 
    virtual ~MonitoredDuration() = default;
 
    Duration getIntervalDuration() const {
        return (interval_duration_);
    }
 
    DurationDataIntervalPtr getPreviousInterval() const {
        return (previous_interval_);
    }
 
    DurationDataIntervalPtr getCurrentInterval() const {
        return (current_interval_);
    }
 
    Timestamp getCurrentIntervalStart() const;
 
    bool addSample(const Duration& sample);
 
    void expireCurrentInterval();
 
    void clear();
 
private:
    Duration interval_duration_;
 
    DurationDataIntervalPtr current_interval_;
 
    DurationDataIntervalPtr previous_interval_;
};
 
typedef boost::shared_ptr<MonitoredDuration> MonitoredDurationPtr;
 
} // end of namespace isc::perfmon
} // end of namespace isc
 
#endif