jk_appmonitoring

Introduction

This Python module contains components for analyzing the use of system resources by processes. It covers two use cases: a) monitoring other processes and b) monitoring one's own process.

Information about this module can be found here:

• github.org
• pypi.python.org

Why this module?

Linux provides a lot of information about processes in the system via the /proc/* file system and other means. However to use this data easily a reasonable API is required. This module provides such an API. Some effort has been made to select appropriate information files and provide information about processes in a way that keeps the I/O and CPU load low.

Limitations of this module

This module is only usable on Linux.

This module can only provide information that is made available through regular system interfaces such as the /proc/* file system.

This module only provides information. This module is not ment to manage processes, it is only ment for retrieval of information about processes via a simple and well documented API. It therefore is ment not as a standalone application but as a building block within another application.

jk_appmonitoring and jk_sysinfo

There is another module you should know about. It's named jk_sysinfo. While jk_sysinfo provides various information about the local machine and the operating system this module named jk_appmonitoring provides information about a single or a set of processes. jk_sysinfo is ment for system analysis and monitoring, jk_appmonitoring is ment for individual process analysis and monitoring.

How to use this module

Import this module

Please include this module into your application using the following code:

import jk_appmonitoring

Core API

The core API provides the following functions:

• dict get_proc_pid_io(int pid, *) : Retrieve information about I/O of a process by parsing /proc/<pid>/io.
• dict get_proc_pid_stat(int pid, *) : Retrieve information about process memory usage and priority assignments by parsing /proc/<pid>/stat.
• dict get_proc_pid_status(int pid, *) : Retrieve information about process memory usage and priority assignments by parsing /proc/<pid>/status.

dict get_proc_pid_io(int pid, *)

For a given process ID this function reads and parses /proc/<pid>/io. From this pseudo-file it will retrieve data and provide it using the following key-value-pairs:

dict get_proc_pid_stat(int pid, *)`

For a given process ID this function reads and parses /proc/<pid>/stat. From this pseudo-file it will retrieve data and provide it using the following key-value-pairs:

dict get_proc_pid_status(int pid, *)`

(TODO)

Retrieving information about processes

(TODO)

Managing Disk Space Information

If you want to display information about disk space the following set of classes can be used for that purpose:

• RFileSystemCollection : This manages all file systems available for analysis
• RFileSystem : This represents a file system available for analysis
• RDirectory : This represents a directory that is used by some part of an application

So the procedure is as follows:

• First instantiate a RFileSystemCollection,
• register all file systems RFileSystemCollection should check later, then
• register instances of RDirectory that represent a set of directories used by your application.
• Then invoke update() to retrieve more or less recent data (by respecting configurations for RDirectory to cache values for some time), and
• then retrieve the data from the RFileSystem objects via property filesystems from the RFileSystemCollection.

Here is a code example:

fsCol = RFileSystemCollection()

# register a single file system - or main file system
fsCol.registerFileSystem(RFileSystem("Main", "/", bWeakDirRefs=False))

# now register various directories for demonstration purposes only
fsCol.registerDirectory(RDirectory("myuser-home", "/home/myuser", 60))
fsCol.registerDirectory(RDirectory("fileproc", "/srv/fileproc", 30))

# now update the file system usage data
fsCol.update()

The RFileSystem objects will now have generated disk usage information. You can access disk usage objects (represented by RDiskSpacePart objects) stored at these file system objects.

Here is a simple example how to do that:

for fs in fsCol.filesystems:
	print(fs.name)
	for part in fs.usages:
		print("\t" + part.name + "\t" + str(part.diskSpaceUsedPercent))

Contact Information

This work is Open Source. This enables you to use this work for free.

Please have in mind this also enables you to contribute. We, the subspecies of software developers, can create great things. But the more collaborate, the more fantastic these things can become. Therefore Feel free to contact the author(s) listed below, either for giving feedback, providing comments, hints, indicate possible collaborations, ideas, improvements. Or maybe for "only" reporting some bugs:

• Jürgen Knauth: pubsrc@binary-overflow.de

License

This software is provided under the following license:

• Apache Software License 2.0