CodeMash 2012 was a “10″

I just got back from CodeMash 2012 – what a blast! This amazing developer-organized conference took place over three days in the brand new convention center at the Kalahari Resort in Sandusky, Ohio — a.k.a. America’s largest indoor waterpark. Inspired talks, awesome people, and meticulous planning by a few with generous support from many combined to make for a truly fantastic event.

On a personal note, there were two little details that touched and inspired me.

1. Leon Gersing gave a heartfelt zen-infused pecha kucha talk on Love that reminded us that work/play/family/friends are synergistically intertwined aspects of a life passionately lived – not competing commitments in a zero-sum game.
2. Designing Interactive sponsored a frickin’ Bacon Bar!
    

The Jam Session at CodeMash 2013 will turn it up to “11″

It got me thinking about what I could do to help make some aspect of next year’s CodeMash a bit more awesome. And it hit me: the Jam Session!

This is near and dear to my heart because I was beating on pianos, organs and various synthesizers for years before I ever touched a computer keyboard. Thanks to Carl Franklin and others, CodeMash has provided space for an open jam session at CodeMash for several years.  But there are a couple challenges with pulling off a great jam session that present opportunities for improvement:

1. Some musicians are a little shy and need a bit of coaxing to feel comfortable jumping in
2. Occasionally, someone needs a gentle nudge to take a break once in a while
3. Negotiating what to play next can be tedious and time-consuming
4. Having the right gear available to play and be heard is easier said than done

Creativity flourishes in a bit of structure. I’ve gotten approval from CodeMash to organize the 2013 Jam Session.  I want to arrange for a house sound system and gear (drum kit, percussion, keys, amps) to be shared as well as working out some simple ways to maximize the fun for players and listeners.  For instance, chord charts and lyric sheets can eliminate a lot of sputtering dead time trying to pick the next song and agree on a key.  Having a sound guy to get instruments miked, blend levels and kill feedback can be a godsend. Having a couple professional (i.e. full-time) musicians to facitate things could help keep things flowing the way a good talk show host makes all the guests sound interesting.

If you’d like to jam at CodeMash 2013 or have any ideas on how we can amp up the awesome, please share in the comments section below.

If you’re already planning on attending, that’s fabulous – we’ll be all over, just look for the guys in the dark blue polos.  If you weren’t planning on it, you should – you might find some late minute tickets from people that couldn’t make it.

Whats on tap from us at CodeMash?  A bunch of things:

• Gary and I are presenting some of our more popular sessions 
• We’ll be demoing Gibraltar 3.0 – with a number of updates not in the previous betas and the first public preview of a completely new part of Gibraltar (oooh!).  Stop by our booth and see everything that’s new before its public release.
• We’ll be showing off the first experiment to escape from Gibraltar Labs (find out what it is at CodeMash – it’s nothing like anything we’ve done before!)
• We’ll be running a contest to help us name our new experiment before it can be released into the wild.  Come up with the best name and you’ll get a new Kindle Fire.
• Along with a few other exhibitors we’ll be part of ButtonMash – stop by our booth to pick up one of our buttons to be entered into the ButtonMash raffle for some really neat prizes.

And that’s just *our* part of the event.  Wow, I’m gettin’ tired just thinking about it.

For Gibraltar 3.0 we’ve introduced a new way of seeing your log data in real time: Live Sessions.  When you enable live sessions you can view log data remotely, efficiently, in real time.  In Analyst you’ll see a new node in the tree view called Live sessions.  When you select that, you’ll see a list of all of the available sessions which you can pick from.

When you first click the Live View tab a data connection is established and you’ll get the last thousand messages that were logged.  Once that data’s come across, new messages are shown as they are recorded.  You can filter the display to show just messages of a particular severity or to search their text for a particular value.

This is your server, live!

If you switch away from one session to another the live view stream will continue to run in the background – keeping it current with the most recent thousand messages.  Gibraltar takes steps to keep this memory efficient so you can have multiple live streams running at the same time without performance issues.

If you want to keep watching an application while you work you can double click it and get an independent window which will update in real time as long as the remote application is running.

Efficient over the Network

The data stream that’s used by Live Sessions is designed to be very efficient over networks.  It is highly compressed (using the same techniques employed by the Agent to write log files), connection based, and only running when there is an active viewer monitoring the session.  In real world scenarios the live stream for a busy server can be easily viewed over a low bandwidth, intermittent connection like a tethered phone or Mifi.

• If the connection is lost, the data stream restarts with the last message you received so it can show you all of the messages
• If no one is watching a live session then the data is buffered in the Agent but not sent across the network.

Safety First

There are a number of features designed to make sure live sessions don’t cause a problem to your application:

• Asynchronous, buffered transmission:  The Agent publishes data to any set of listeners asynchronously from recording the log file to ensure slow network connections or network connectivity problems won’t slow down recording the main log file.
• Drop on overflow:  If there are more log messages waiting to be sent than can be sent over the network new messages will be dropped instead of holding up the application.  This is in contrast to the log file which will switch to synchronous while it catches up.
• Encryption optional:  You can choose to enable SSL for live session communication so it will be encrypted end-to-end.

Live Sessions and Firewalls

The Live Session protocol is designed to work with most firewall configurations:

• All connections are outbound: The Agent and Analyst establish connections to the central server to communicate.  No connections are directly created between the Agent and Analyst.  This works well with NAT and often requires no explicit firewall rules or exceptions.
• Separate ports are used for Agent and Analyst:  If you need to create a firewall rule you can create separate rules for Agent and Analyst traffic (ports 29970 and 29971 respectively)
• Connections are asynchronous:  Many firewalls will simply fail to respond to attempts to connect to ports that aren’t open, causing very long timeouts.  By performing all connections asynchronously this prevents the application from being unresponsive.

Try it out Today

If you’d like to check out Live Sessions for yourself, you’ll need to download the latest build of Gibraltar 3.0 and upgrade to the included Agent, Analyst and Hub.  The Hub Server does the central relaying between agents and analysts so it has to be set up in the center.  Live Sessions are not available with the subscription Hub Service operated by us at this time, you have to have your own private Gibraltar Hub.

using System.Collections.Generic;
using System.Linq;
using System.Diagnostics;

namespace GibraltarGettingStartedApp
{

	class Program
	{
		static int Main(string[] args)
			{
				Trace.WriteLine("About to Blow up...");
				int zero = 0;
				Trace.Close();
				return 1 / zero;
			}
		}
	}
}

That should get the runtime’s panties in a bunch, let’s try it.

Yep, that did it! Now, let’s see what Gibraltar logged…

Gibraltar knows we crashed and if we open up the record…

We know what the problem was, we can click the link and go right to the line in the source code and Gibraltar tells us what the user experience is going to be, “This fatal error will not be reported to the user, then the application will exit”. All and all, pretty cool.

As an aside, let me close down VS, I want to test if I click the link, will it open the file and go to the line? It does! That’s cool, though I notice that it only opens the actual file and not the solution or project that the file is in. Hmm, I’ll need to investigate that more as it’d be better if the entire solution was opened, don’t you think?

Let’s try running the same unhandled exception in a winforms application and see what happens. We’ll need to run the exe from the commandline, as the VS debugger will “get in the way” and try to do “clever stuff”, but when we do, we see the following dialog:

Here Gibraltar is giving us even more help. It’s popped up a dialog which will actually help us recover from the crash and carry on using our application. If we select “Restart Application” Gibraltar will restart the application for us and enable us to carry on using our application. Of course, this facility should only be used in a testing environment. In the real world, I don’t think it would be wise to restart and to continue using an application which had just suffered from a crash, as there is no way to know what state the underlying model is in. However, from a testing perspective, it’s an excellent tool.

Of course, the same information is recorded in Gibraltar:

Notice that the “Status” has been recorded as “Normal”. If we open the record we can see why:

It’s because we chose to continue the execution and shut down the application normally after.

Okay, let’s change our console application code to handle the exception…

using System;
using System.Collections.Generic;
using System.Linq;
using System.Diagnostics;

namespace GibraltarGettingStartedApp
{
	class Program
	{
		static int Main(string[] args)
		{
			Trace.WriteLine("About to Blow up...");
			int zero = 0;
			Trace.Close();
			try { return 1 / zero; }
			catch (DivideByZeroException e) { }
			return 0;
		}
	}
}

And let’s see what difference that made to Gibraltar…

Hmm, as far as Gibraltar is concerned everything is normal, there is no sign of the handled exception. For a clue as to why that is, let’s examine logging best practices, you can read them at…

http://www.gibraltarsoftware.com/Support/Documentation/Logging_BestPractices.html

And they quite clearly state:

“We strongly recommend that in all cases where an exception is consumed within a catch block that you log the exception with an Informational severity rather than silently swallowing the error.”

Okay, so this states that if we handle an exception, and we want that fact recorded by Gibraltar, then we have to log it. That makes sense really. So, let’s change our code to the following:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Diagnostics;

namespace GibraltarGettingStartedApp
{
	class Program
	{
		static int Main(string[] args)
		{
			Trace.WriteLine("About to Blow up...");
			int zero = 0;
			try { return 1 / zero; }
			catch (DivideByZeroException e)
			{
				Trace.WriteLine("Error: " + e.Message);
			}
			Trace.Close();
			return 0;
		}
	}
}

Now let’s see how that’s affected Gibraltar:

This time you can plainly see that the error has been recorded, which is good, but notice too that there’s no exception tab:

Of course, we should be able to do better and we can. If we use the TraceInformation method, and pass a formatted string, along with the exception, then Gibraltar will give us a much richer experience.

So, let’s change our code to use that method:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Diagnostics;

namespace GibraltarGettingStartedApp
{
	class Program
	{
		static int Main(string[] args)
		{
			Trace.WriteLine("About to Blow up...");
			int zero = 0;
			try { return 1 / zero; }
			catch (DivideByZeroException e)
			{
				Trace.TraceInformation("Error: {0}",e.Message,e);
			}
			Trace.Close();
			return 0;
		}
	}
}

And let’s look at the information provided in Gibraltar:

This time, as you can see, we get the “Exceptions” tab. This is because Gibraltar scans the insertion variables and, if it finds one that is an exception, then it uses that as the exception for the log message (regardless of its severity). Pretty cool eh?

In this post we added an unhandled exception to your console application to see what effect that had on Gibraltar. We then added an unhandled exception to a winforms application so we could see the enhanced features available to us there and then we finished up by handling that exception and seeing why best practice is to log handled exceptions.

I hope you’ll join me next time as we continue our exploration of Gibraltar, until then, happy coding!