This has it’s advantages (awesome flexibility) and disadvantages (slooowwww progress..). One problem I have is monitoring my servers throughout the day and night. I obviously don’t have a team of sys admins watching my server performance all day long and monitoring my network topology. But, since I am building commercial apps, I do need to get alerts when something terrible has gone wrong. Hopefully, by planning ahead I’ll then be able to fix the problem as quickly as possible (like having ssh available on my iPhone!)

There are two ways that are a sure-fire way to alert me quickly, email or a text message. It turns out, one simple command in a C++ program can send both to me using standard libraries:

system(“echo ‘Help I have crashed and I cannot get back up!’ | sendmail myemail@mailserver.com”);

Now this requires your server to both allow “system()” calls and to have the standard command line tool “sendmail” set up properly.  I HIGHLY recommend you test both things before relying on this for an emergency call (see code snippet below)!

This can be even more useful if your mobile service provider has set up email-to-text services.  Luckily, most of the major providers have this up and running.  You simply replace the email address with the address you need to send to your phone:

system(“echo ‘Help I have crashed and I cannot get back up!’ | sendmail 2125551212@txt.myprovider.com”);

Like magic, you’ll receive an instant alert that will send you scrambling away from almost any social interaction to try and solve!

I place these alerts in my SIGTERM and SIGINT signal catchers.

Be warned, however, if your program gets sent a SIGKILL, hangs somewhere unusual, or your server hardware simply crumps somehow, you WILL NOT GET AN ALERT!  This is where you need a redundant, external, monitoring program running on separate hardware, power, and network connection as a belt-and-suspenders check.

You did build an interface in your mission-critical server for an external monitoring program to connect to didn’t you?

A little snippet of standalone test code you should be able to compile is shown below.  Remember to change the email address to match your own!

#include <stdlib.h>

int main(int argc, char * argv[]) {
        system("echo 'c++ test' | sendmail myemail@myserver.com");
        return 0;
}

Happy coding!

Mike

Finding CPU usage from within a C++ program turned out to be one of the more obscure things to accomplish.  I did plenty of searching online and came up with many answers and even a few libraries that appear to give access to the data.  But, the libraries seemed overly large for what must be a simple task and the examples I found were incomplete.

In the end, I opted for using standard unix/linux commands.  From a command line, if you were to type “ps aux | grep MyAppName” you would get a line similar to this:

username   20657  99.6  0.0    75328    332 s000  R+   10:38PM   0:13.48 ./MyAppName

The first number after “username” is the CPU usage (99.6) of your program and the second number is the memory usage (0.0).  It seemed to me you should be able to use this formatted information pretty easily.

It turns out you can using a combination of system() command, command line piping and redirection, and file parsing.  It’s fast, simple, and effective..  Just what I was looking for.  The following code will get it done for you:

—-

#include <boost/algorithm/string.hpp>
#include <boost/regex.hpp>
#include <boost/algorithm/string/regex.hpp>

#include <time.h>
#include <stdlib.h>

#include <sstream>
#include <iostream>
#include <vector>
#include <string>

using namespace std;
using namespace boost;

int main (int argc, char * const argv[]) {
	// First get my process ID
	int myProcID = getpid();

	// Now we use system commands to find our process id and store the result in a standard text file
	// The "grep -v grep" command filters out the system command itself from the process search.
	stringstream theCommand;
	theCommand << "ps aux | grep " << myProcID << " | grep -v grep > result.txt";
	 time_t lastCheck = time(NULL);
         while (1) {
 		time_t now = time(NULL);
 		 // Only print every 5 seconds or so to prevent overwhelming the output
 		if ((now - lastCheck) >= 4) {
			// The clock code is here to show how efficient this method can be.
			clock_t start = clock();

			// Run the command
			system(theCommand.str().c_str());

			// now open the text file and read the result line
			ifstream infile;
			infile.open("result.txt");
			string aLine;
			getline(infile, aLine);

			// print the line just so you can see it.
			cout << aLine << "\n";

			// set up a receiver for the boost split function
			vector<string> processParameters;
			// Split the recieved line on the " " seperator.  There are multiple spaces between parameters, so use token_compress_on
			split( processParameters, aLine, is_any_of(" "), token_compress_on );

			// Output the results
			cout << "My CPU usage is " << processParameters[2] << ", and mem usage is " << processParameters[3] << "\n";

			// Close the file (you might want to delete it too.)
			infile.close();

			// reset my time check
			lastCheck = now;

			// show how quick this is.  On my machine it's ~ 650 clock cycles (at 1.83 GHz, thats approx 3 10-millionths of a second)
			cout << "CPU check took " << (clock() - start) << " cycles to complete\n";

		}
	}
        return 0;

}

—

I’ve used the boost library here to simplify the parsing of the text line.  You don’t need to do that if you don’t want to, but I assure you you’ll find using boost easier than spinning your own text parsing code.

Happy coding!

Mike

There was only one problem.  The Crypto++ library is indeed a very powerful set of cryptographic tools, but I found the learning curve to get my first apps running with it to be very high.  I examined all the sample code I could find, worked through the API documentation, and examined the validation and test code before I finally started catching on.  Then I had to “grep” my way through the files to identify which headers I needed to include for a given function.

DISCLAIMER: All of this brainache is undoubtedly due to my own lack of skill and formal training.

Nevertheless, I overcame my deficiencies and learned how to encrypt and decrypt at will.  But, I was unhappy with the amount of extra code I had to put everywhere I wanted to encrypt and decrypt something.  So, I ended up writing a simplification wrapper to make my work easier.  My wrapper uses only a small subset of functionality and algorithms in Crypto++, but it makes using that subset very easy.

As a very small example, here is how you encrypt a given plaintext string:

string cipherText = BasicCryptoPPWrap::EncryptStringAES(“Encrypt me”, key, initVector, errFlag, errMsg);

The wrapper also implements a custom Advanced Encryption Standard protocol that stores the initial vector with the encrypted data, so you don’t have to track it yourself.  I have used this wrapper very successfully in my own work, I think you’ll find it useful too!

Wrapper functions:

• Implements symmetrical AES encryption and decryption
• Hex encoding of binary data
• Hex decoding of hex-coded strings
• Generic string and file encryption
• Custom protocol string and file encryption
• Random bit and byte generators
• SHA-256 Hash generator

The wrapper is not a standalone solution.  It requires your code to link to libcryptopp and know where the cryptopp header files are found.  The Crypto++ website can help you set up your system.  Once you get the validation suite to run successfully, you will be able to use this wrapper.

Get the files here:

• BasicCryptoPPWrap.h – The header file that makes it all happen
• example.cpp – An example file that takes you through all the functions available in the wrapper

Good luck!  I release this wrapper into the public domain, but if you happen to use the code I wouldn’t mind hearing about it!  Credit might be nice too!

Mike

After several tries, I came up with my logger class.  Basically, using static class members and c-style macros, I came up with a logging method that turns on and off easily, allows easy redirection, and is easy to use everywhere in your code.

At it’s simplest, this logger is used as such:

#include <iostream>
#include "logger.h"

using namespace std;	

int main (int argc, char * const argv[]) {
	bool someLogType = true;
	LOG(someLogType) << "This will be logged to clog\n";
	return 0
}

But the logger class also offers globally accessible log types and the ability to redirect the output wherever you want. The following snippet shows this use.

#include <iostream>
#include <sstream>
#include "logger.h"

using namespace std;	

int main (int argc, char * const argv[]) {
	// Set these to turn various logs on or off dynamically
	NORMAL = true;
	DEBUG = false;
	VERBOSE = true;

	LOG(NORMAL) << "This will log\n";
	LOG(DEBUG) << "But this one won't\n";
	LLOG(VERBOSE) << "This one will log, but with the name of the logtype prepended to the message\n";

	// Now we redirect the log output to a custom location.  This could be a file or any ostream
	stringstream newLog;
	logger::setOutstream(newLog);

	LOG(NORMAL) << "This will log\n";
	LOG(DEBUG) << "But this one won't\n";
	LLOG(VERBOSE) << "This one will log, but with the name of the logtype prepended to the message\n";

	string results = newLog.str();
	cout << "In the new log: \n" << results << "\n";

	// Always reset the logger to clog before the program exits or you will get a BAD_ACCESS error
	// I'm still trying to work out that problem, but this is an easy fix for now
	logger::setOutstream(clog);
	return 0;

}

Get the code here:

• logger.h
• logger.cpp
• example.cpp

Good luck and good coding!