Author: admin

You might be wondering how I keep track of the development of Leaf Node Monitoring. This short post goes into detail regarding how I keep track of ideas, new features and bugs and how the code is automatically tested and built for the various platforms.

Since it is a project I can only work on in my spare time, it is not updated as rapidly as you might expect, an evening a week here and there.

It is also my pet project so I want new features to be useful, work great and look okay, which means I can nitpick on a layout for a month and then decide I don’t like it and start over.

The development is done in C++ with Qt, both Qt5 and Qt6 are supported but I target Qt5 with Windows 7 as minimum platform for compatibility with older but perfectly fine hardware. The Qt6 port is mostly there to make sure the code compiles if I ever wanted to switch.

Bug tracking & new features

Keeping track of all the ideas I have is done with Gitea. I have a self-hosted instance running locally and that hypervisor is limited in RAM so Gitlab was out of the question. Using the Issues and Projects features I keep track of my ideas and bugs. Here is a screenshot of the New Features board:

Automated builds and tests

For automatic builds I use Woodpecker, a self hosted CI system based on Docker containers. I could have put it all up on Github or Gitlab but I want to be in control of the source code, not put it on some third party that might have different profit-motives in a year and start charging a boatload of cash for it. Self-hosting means I am in control of when I update. Especially with the older compatibility in mind, I cannot be sure that Qt 5 will be available on the Github Actions free images in a few years from now. Gitlab is an option but that uses so much resources that I’d rather not. It has so many features I don’t need and cannot turn off. 

Here is a screenshot of my CI build running:

The CI automatically builds the Linux version, both Qt 5 and Qt 6 and runs the unit tests. I’m working on an automated Android build but that has low priority.

Unit tests are an important part of my workflow, almost all code is unit-tested one way or another. Not all classes have tests, some are tested by the parts of the application that utilize them. Code coverage is around 70% and I strive for 50% or up.

Windows builds

The Windows builds are done on a Windows 7 machine (not connected to the internet) with just Qt and InnoSetup installed. Mostly automated using a few batch scripts:

Most of the Windows testing is done on Windows 10 or 11 on actual machines but the final build is done on this Windows 7 box, 32 bit, Qt 5.15.

The source is always available in the app so if anyone wants they can compile a more optimized version themselves. The source code is also sent when you purchase the application on here.

If you have any specific questions regarding my development workflow, don’t hesitate to send me an email.

I’m pleased to announce the next version of Leaf Node Monitoring, the simple and easy to use open source site and server monitoring tool. Major new features include a responsive and adjustable layout, massive performance improvements and a new check type, allowing you to execute external processes, for example, the nagios/monitoring plugins.

You can download the new version here. Existing customers can open their purchase confirmation email and re-download, I’ve updated the assets. If you have any issues, please shoot me an email.

Let’s start off with a screen recording of the new version, demonstrating the new responsive layout. Note that any stuttering is due to the recording software.

The biggest but least visible new feature in this release is the massive speedup. All checks now run in their own thread, with intelligent thread management making sure the UI is not blocked. Valgrind and QML Profiling also showed a few pain points which have been resolved to make LeafNode Monitoring feel way more snappy. Using the Loader in QML to only load parts when required and not passing huge amounts of text via Qt signals/slots are a few of the other speed improvements. This is also the reason why this version took so long to release, I’ve rewritten the threading related code multiple times and only now am I a bit satisfied with it.

I’ll now go over the other new features in more detail.

Responsive Layout

One request I got from multiple people was to make the app more usable on larger screens, like a wall mounted monitor. Here is a picture showing a 2 column layout: Using the new controls, visible after clicking the arrow at the bottom of the app, you can resize the host cards and check tiles. Make them huge for a wall mounted monitor, make them small on your high-dpi Android phone.

Here is a side by side comparison of the previous version (2022.01) together with this version, showing the same hosts. Can you imagine how much more useful this is on a big screen?

v2022.01 (old)	v2023.01 (new)

My intention always was to have Leaf Node Monitoring running in a small window on the side. Since failed checks automatically are placed at the top, a quick glance should show you enough. But, I’m more than happy to incorporate user feedback, and I find setting the layout to be a bigger improved readability.

Earlier I’ve written an article showcasing the new layout feature, you can read it here. Another visual improvement is the rounding of most corners. Since the most-used operating system in their 11th version also rounded corners, I thought, why not, lets be fancy.

External Process Checks

The other major new feature is a new check type, namely External Process checks. This allows you to configure any process and when it exit with an exit code other than 0, it will trigger an error. On the Linux side you can use the monitoring plugins, on Windows you might use Powershell, for example a `Get-Process` command. The README file and the build in help list examples for both PowerShell and Linux. Here’s how it looks when you add a check:

Here is how a successful check and a failed check look, both on Windows as on Linux:

Synology SNMP disk temperature check
Windows Process running check

I’m still thinking about how to design a better check add / host edit screen. At the moment it still is a bit of a big list of buttons and fields. Keep an eye out for new versions since that is high on my todo list. But, adding this external process integration extends the functionality of LeafNode Monitoring by a huge amount, since you can now add any check or script you want and don’t have to wait until I add it myself.

Notifications for individual checks

In the previous version, you were only notified when of a host status change and you had to go look yourself to see which check failed. Now you also receive notifications for each individual check. No history (yet), your window manager / operating system alert history is a useful alternative for now.

Tray icon menu

On the desktop, the tray icon can now be right-clicked to open a menu allowing you to quickly check all hosts or start/stop the timer or disable/enable notifications:

This is a small quality of life improvement which I find myself using often, more than I expected.

Other fixes / additions

The output of a check can now be selected (and copied).

Unit tests are added to the code and a CI build system has been setup.

Reworked the visual timer indicator. Now the timer only starts counting down if there are no more checks running. Most controls are now disabled when there are checks running.

Qt6 compatibility. Source code builds with Qt 6 and unit tests are ran with both Qt 5 and Qt 6. Binaries are still distributed as 32-bit Qt5 for Windows 7 and older Linux compatibility.

Added button to add a ping check to a target. The ping check could be removed, but not added (without removing the entire target).

You can now configure the amount of hosts that are checked concurrently and the amount of checks that each host runs concurrently. If you have a slower or older Android phone, it might help to set this to 1 or 2, on a fast desktop you could set it way higher.

When a check fails, it is retried up to 4 times. For example if you have one missed ping packet, you won’t get a notification, only if 4 consecutive ping’s have an error.

When a HTTPS check fails, the output now gives more information including the certificate:

A quick update, showcasing another new feature for the upcoming version of Leaf Node Monitoring (v2022.02), responsive layouts.

The previous version has a set width/height for the host cards and check tiles, in a big long column, just 1 row. Widen the window, host cards also widen. With this change, the host cards no longer automatically widen, but once the window is big enough, 2 rows will appear.

Here is a GIF showcasing the new responsive behavior:

(stuttering is due to the GIF screen recording, actual app performs way better)

The old layout just became as wide as the screen:

I’ve added a collapsible menu right on the monitoring screen so you can resize and directly see the result. The new options are also available in the settings screen.

This responsive layout feature was requested by a user that runs Leaf Node Monitoring on a tablet and wanted to use the screen real estate better.

The technical details on how to make a responsive QML layout can be found here: https://raymii.org/s/articles/Responsive_Qml_layout_with_scrollbars.html – Using QML layouts, I can dynamically add or remove columns or rows in the grid layout that holds either the host cards or check tiles. I also added a short animation on resize, as eye candy and also because QML makes that so easy.

One more sneak peek

I’ve also added a right-click menu to the tray icon with
a few useful features:

Just because I missed that feature myself.

In my spare time I’m slowly working on the next version of Leaf Node Monitoring. Sales have been above expectation and I have many more ideas I want to implement. Had quite some positive feedback, thanks to all of you who wrote in.

External Process checks

One of the big new features in the next release (v2022.02) will be external processes as monitor checks. Here is a screenshot of two external checks on Android:

You might notice that they’re orange, which means warning status. You might also notice the visual changes, rounded corners and other small tweaks. External processes are simple checks that are successful (OK) when the exit code is 0 and critical otherwise. In this case, they’re warning because some errors, like a nonexistent binary, do not trigger critical (since, no exit code is not the same as exit code > 0).

External processes allow you to have many more checks. I use the checks from Nagios / Icinga, available via https://www.monitoring-plugins.org/, which extend the functionality of Leaf Node Monitoring by a huge amount. I will still continue to implement new checks in native C++, both for speed and cross-platform functionality, but this feature will help in all the cases where there are no checks yet.

Retry attempts

  The next new feature is retry attempts. For all checks currently, like the TCP port or HTTP check I’m implementing an automated retry. Currently 4 times, but I might make that configurable in the future. If a check fails, it will be retried with the same parameters. No back-off timer or pause in between yet. I’ve been running LeafNodeMonitoring myself and have noticed some notifications which were flaky tests, with the automated retries I hope to have less of those.

Unit tests

The last new thing is that I’ve begun to add unit tests. For most of my private projects I don’t do unit tests since they’re not worth the time/effort. At work they’re required and we have automated checks that reject merge requests when there is not enough coverage. Unit tests are not user facing, but they do help in delivering better software. With the growing amount of checks and logic, I am now of the opinion that Leaf Node Monitoring benefits from tests. Since I’m used to write code that can be tested (small methods, decoupled, dependency injected, etc), it does not require any refactoring, I’m noticing most of the code is already testable just fine.

Here is an example test that checks if the new external process code fires off the correct signals and returns the correct result when it receives an exit code of 0:

TEST_F(ExternalProcessCheckTest, exitCodeZeroShouldGiveOkayResult)
{
    //arrange
    QString fullPath = "/bin/bash";
    QStringList arguments;
    arguments << "-c 'exit 0'";
    epck = new ExternalProcessCheck(*target, fullPath, arguments, timeout);
    QSignalSpy signalSpy_checkResultChanged(epck, &ExternalProcessCheck::checkResultChanged);

    //act
    emit epck->startCheck();
    signalSpy_checkResultChanged.wait(1000);

    //assert
    EXPECT_EQ(epck->checkResult(), MonitorEnums::CheckResult::Ok);
    EXPECT_EQ(signalSpy_checkResultChanged.count(), 1);
}

The constructor and destructor of this test suite handle the deletion of the pointers and further cleanup, so don’t worry about the naked new.

It’s always hard to test external programs like this, as is testing time-related stuff (without a lot of stubs/mocks). I’m using the googletest framework since I’m used to it. It requires a bit of shoehorning to make it works with Qt but once your project is setup correctly it’s a breeze to use. I had to convert the one project to three projects (a library, an application and a test-app) using SUBDIRS in qmake and linking to the library in the main application. Not rocket science, but I imagine it can be hard to do if you don’t know what to look for.

Code coverage is now up to 57% so that’s a great start.

That’s all for this post, I’m not sure when the next version is going to be released, but it will be a free update for all of you who purchased it. If you have any feature requests, issues or want to let me know something, don’t hesitate to contact me.

Leaf Node Monitoring is now available in the Google Play store. I did not expect the app review to be done so quickly, for my other app, WeatherTerminal, which I uploaded as a test to get the store account in order, took more than a week to review, Monitoring was done in two days, and it’s a way more complex app.

If you purchase via the Google Play store, you don’t get the Linux version or the Windows version, only the Android version. The app can export its own source code, so you can build the other versions if you want, but it is a bit more trouble than if you buy the regular version. The play store version also does not allow you to choose your own price as the regular version does. But still, it’s available to any Android phone via the built in secure store, so that’s a big thing!

I’ve just finished up the first release of Leaf Node Monitoring, yay! A simple monitoring program, perfect on your desktop, unobtrusive, to keep an eye on your sites and servers. Written in C++ & Qt 5, licensed under the GNU GPLv3.

Download it here. 

The first release, version 2022.01 can export its own source code and includes the following checks:

• Ping
• HTTP Get
• HTTPS Get
• TCP port

When you add a host, a few standard ports are probed and added as a check. If HTTP/HTTPS is detected, those are added instead of port 80/443.

I’m preparing the first initial release of Leaf Node Monitoring. After writing a few articles on the plans and licensing details, I’ve now almost finished the last things I wanted to do before the initial release. I’ve got a rather large TODO list but the feature set I have now is enough to get a version out of the door.

The installer for Windows is finished, using InnoSetup,  a few details like app name/ icon / version in the binary on Windows are done and for most Linux versions I’ve got an AppImage with Qt statically compiled. Runs on Ubuntu 18.04 and up, and of course the source will be delivered to customers, so they can compile it Leaf Node Monitoring themselves on any distro.

Business details are sorted as well, including payment provider, website and not having to register as a company due to not wanting to make a profit, kind of a grey area, but probably fine.

Last but not least, the colour scheme is toned down a bit and I’ve implemented a simple version check in the app, which will show a message if a new version is available. You can turn this message off via the settings. Here is a video showing that setting and the version check. I like the little animation the green bar has, the GIF recording does not show that particularly well:  

The version check is implemented as a HTTP request to a text file containing the latest version number. Qt provides a few nice modules to make that easy and asynchronous. QNetworkAccessManager, QNetworkRequest QNetworkReply make this a breeze. In Qml it might be simpler but that is cheating since it’s just JavaScript.

No cryptographic signing or transport layer security is used. To complex for a first version and I can always add that later. The notification is on by default, but I’m doubting if I keep it that way. If you have any thoughts regarding a default update notification, please let me know.

Please also send me any other thoughts and comments. Not sure on the time frame of the release, but as far as technical things, almost ready.