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