Skip to content

Microservice Monitor

The MicroserviceMonitor class collects CPU, RAM, and bandwidth usage metrics at a predefined interval for each "vMicroservice" in the simulation. It allows you to track the resource consumption of microservices and analyze their performance.

MSMonitor

Source code in PyCloudSim\monitor\ms_monitor.py 
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
class MSMonitor:
    _monitored_ms: Union[vMicroservice, List[vMicroservice]]
    _df: pd.DataFrame

    def __init__(
        self,
        monitored_host: Optional[vMicroservice | List[vMicroservice]] = None,
        monitor_interval: Union[int, float] = 0.01,
    ) -> None:
        """vMicroservice Monitor.

        Args:
            monitored_host (Optional[vMicroservice  |  List[vMicroservice]], optional): if one, all microservices will be monitored. Defaults to None.
            monitor_interval (Union[int, float], optional): the sampling interval. Defaults to 0.01.
        """        
        if monitored_host is None:
            self._monitored_ms = simulation.MICROSERVICES
        else:
            self._monitored_ms = monitored_host
        self._monitor_interval = monitor_interval

        self._df = pd.DataFrame(
            {
                "ms": pd.Series(dtype="str"),
                "ms_id": pd.Series(dtype="str"),
                "time": pd.Series(dtype="float"),
                "cpu_util": pd.Series(dtype="float"),
                "ram_util": pd.Series(dtype="float"),
                "num_containers": pd.Series(dtype="int"),
                "num_scheduled_containers": pd.Series(dtype="int"),
                "num_non_scheduled_containers": pd.Series(dtype="int"),
            }
        )

        self._process = Actor(
            at=0,
            step=self.monitor_interval,
            action=self.action,
            priority=MONITOR_PRIORITY,
            label="Host Monitor",
        )

    def action(self):
        """Telemetries collection."""
        if isinstance(self._monitored_ms, list):
            for ms in self._monitored_ms:
                if not ms.terminated:
                    host_telemetry = pd.DataFrame(
                        {
                            "ms": ms.label,
                            "ms_id": str(ms.id),
                            "time": float(simulation.now),
                            "cpu_util": ms.cpu_usage_in_past(self.monitor_interval),
                            "ram_util": ms.ram_usage_in_past(self.monitor_interval),
                            "num_containers": len(ms.containers),
                            "num_scheduled_containers": len(
                                [
                                    container
                                    for container in ms.containers
                                    if container.scheduled
                                ]
                            ),
                            "num_non_scheduled_containers": len(
                                [
                                    container
                                    for container in ms.containers
                                    if not container.scheduled
                                ]
                            ),
                        },
                        index=[0],
                    )
                    self._df = pd.concat([self._df, host_telemetry], ignore_index=True)
        elif isinstance(self.monitored_ms, vMicroservice):
            host_telemetry = pd.DataFrame(
                {
                    "ms": self.monitored_ms.label,
                    "ms_id": str(self.monitored_ms.id),
                    "time": float(simulation.now),
                    "cpu_util": self.monitored_ms.cpu_usage_in_past(self.monitor_interval),
                    "ram_util": self.monitored_ms.cpu_usage_in_past(self.monitor_interval),
                    "num_containers": len(self.monitored_ms.containers),
                    "num_scheduled_containers": len(
                        [
                            container
                            for container in self.monitored_ms.containers
                            if container.scheduled
                        ]
                    ),
                    "num_non_scheduled_containers": len(
                        [
                            container
                            for container in self.monitored_ms.containers
                            if not container.scheduled
                        ]
                    ),
                },
                index=[0],
            )
            self._df = pd.concat([self._df, host_telemetry], ignore_index=True)

    @property
    def df(self):
        """The pandas dataframe of the host monitor."""
        return self._df

    @property
    def monitored_ms(self) -> Union[vMicroservice, List[vMicroservice]]:
        """The monitored microservices."""
        return self._monitored_ms

    @property
    def monitor_interval(self) -> Union[int, float]:
        """The sampling interval."""
        return self._monitor_interval

df property

The pandas dataframe of the host monitor.

monitor_interval: Union[int, float] property

The sampling interval.

monitored_ms: Union[vMicroservice, List[vMicroservice]] property

The monitored microservices.

__init__(monitored_host=None, monitor_interval=0.01)

vMicroservice Monitor.

Parameters:

Name Type Description Default
monitored_host Optional[vMicroservice | List[vMicroservice]]

if one, all microservices will be monitored. Defaults to None.

 None
monitor_interval Union[int, float]

the sampling interval. Defaults to 0.01.

 0.01
Source code in PyCloudSim\monitor\ms_monitor.py 
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
def __init__(
    self,
    monitored_host: Optional[vMicroservice | List[vMicroservice]] = None,
    monitor_interval: Union[int, float] = 0.01,
) -> None:
    """vMicroservice Monitor.

    Args:
        monitored_host (Optional[vMicroservice  |  List[vMicroservice]], optional): if one, all microservices will be monitored. Defaults to None.
        monitor_interval (Union[int, float], optional): the sampling interval. Defaults to 0.01.
    """        
    if monitored_host is None:
        self._monitored_ms = simulation.MICROSERVICES
    else:
        self._monitored_ms = monitored_host
    self._monitor_interval = monitor_interval

    self._df = pd.DataFrame(
        {
            "ms": pd.Series(dtype="str"),
            "ms_id": pd.Series(dtype="str"),
            "time": pd.Series(dtype="float"),
            "cpu_util": pd.Series(dtype="float"),
            "ram_util": pd.Series(dtype="float"),
            "num_containers": pd.Series(dtype="int"),
            "num_scheduled_containers": pd.Series(dtype="int"),
            "num_non_scheduled_containers": pd.Series(dtype="int"),
        }
    )

    self._process = Actor(
        at=0,
        step=self.monitor_interval,
        action=self.action,
        priority=MONITOR_PRIORITY,
        label="Host Monitor",
    )

action()

Telemetries collection.

Source code in PyCloudSim\monitor\ms_monitor.py 
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
def action(self):
    """Telemetries collection."""
    if isinstance(self._monitored_ms, list):
        for ms in self._monitored_ms:
            if not ms.terminated:
                host_telemetry = pd.DataFrame(
                    {
                        "ms": ms.label,
                        "ms_id": str(ms.id),
                        "time": float(simulation.now),
                        "cpu_util": ms.cpu_usage_in_past(self.monitor_interval),
                        "ram_util": ms.ram_usage_in_past(self.monitor_interval),
                        "num_containers": len(ms.containers),
                        "num_scheduled_containers": len(
                            [
                                container
                                for container in ms.containers
                                if container.scheduled
                            ]
                        ),
                        "num_non_scheduled_containers": len(
                            [
                                container
                                for container in ms.containers
                                if not container.scheduled
                            ]
                        ),
                    },
                    index=[0],
                )
                self._df = pd.concat([self._df, host_telemetry], ignore_index=True)
    elif isinstance(self.monitored_ms, vMicroservice):
        host_telemetry = pd.DataFrame(
            {
                "ms": self.monitored_ms.label,
                "ms_id": str(self.monitored_ms.id),
                "time": float(simulation.now),
                "cpu_util": self.monitored_ms.cpu_usage_in_past(self.monitor_interval),
                "ram_util": self.monitored_ms.cpu_usage_in_past(self.monitor_interval),
                "num_containers": len(self.monitored_ms.containers),
                "num_scheduled_containers": len(
                    [
                        container
                        for container in self.monitored_ms.containers
                        if container.scheduled
                    ]
                ),
                "num_non_scheduled_containers": len(
                    [
                        container
                        for container in self.monitored_ms.containers
                        if not container.scheduled
                    ]
                ),
            },
            index=[0],
        )
        self._df = pd.concat([self._df, host_telemetry], ignore_index=True)