Some of us may have heard or used MiniProfiler a profiling library for your ASP.NET applications, from the StackExchange team. We carried an article on dotnetcurry.com on it. Today we are going to review another OSS project called Glimpse from a team led by Anthony vander Hoorn and Nik Molnar.
Glimpse recently launched v1.4 with a new Heads up Display (HUD) for the profile information!
On the outset, Glimpse looks to have the same or overlapping functionality as MiniProfiler, but after playing with it for about 5 minutes, I realized, Glimpse provides significantly more insight into the happening of your Application than MiniProfiler. So without further ado, let’s dive in and see what Glimpse can do for us.
This article is published from the DNC .NET Magazine – A Free High Quality Digital Magazine for .NET professionals published once every two months. Subscribe to this eMagazine for Free!
Getting Started with Glimpse
To start off with, we wanted a project with some functionality already built in. We thought it would be good to use the same project that we used for our MiniProfiler for a fair comparison. So we went ahead and downloaded the Source code as Zip from the Github Project.
Glimpse is distributed via Nuget packages, so the easiest way to get started with it is to fire up the Manage Nuget Packages dialog and search for ‘Glimpse’.
Depending on the type of project you want to add Glimpse to, you can select MVC3, MVC4 or in case of WebForms, Glimpse ASP.NET. In our case, I selected Glimpse MVC4, this installs the Glimpse ASP.NET and Glimpse Core packages as well. The following packages get installed
Glimpse Changes under the hood
The Glimpse architecture is based on HttpHandlers and HttpModules. So Glimpse installation basically implies registering the required modules. Let’s look at the web.config changes
New Glimpse section: We have a new Glimpse section for glimpse specific settings.
The Handler and Module Registration: Next we have the Glimpse module and the Glimpse.axd registered.
The Glimpse Policy section: We will look at policies in a bit. This section is for configuring Glimpse specific settings that include when should Glimpse record data and when not, as well as when should the data be displayed, so on and so forth.
From the configuration point of view, Glimpse is all set, unlike MiniProfiler we don’t have to get it going with a call in the Global.asax. So far zero code required.
We can run the application now and navigate to /Glimpse.axd. This will give us the following page
Starting Glimpse is as simple as hitting the ‘Turn Glimpse On’ button.
Now when we navigate back to the home page, we should see the Glimpse HUD at the bottom of the page. If it’s not expanded, click on the ‘g’ logo to expand it.
As we can see above, the Heads Up Display panel from Glimpse gives us a quick view of what’s going on with our Request (Glimpse as it’s subtly obvious, works per-HTTP Request). In the panel, we see three sections
1. HTTP: Shows the request took 973 ms to complete, of which 3ms was ‘on the wire’ meaning the time between the client requesting and server receiving the request. Next 22 milliseconds were spent by the server to process the request and finally 948 seconds by the client to receive and render the Server’s response.
2. Host: Shows details of activities on the server. We can see here that it took almost no time to resolve the correct Action and the View rendering took 3 ms. If we hover over it, we’ll see a little more details
3. AJAX: The final section shows the number of AJAX requests. This page had 0 requests but when we do have AJAX requests, hovering over the AJAX section will show us more details for each AJAX request made.
So that was the HUD for Glimpse and we have gotten off to a good start. Still it looks similar to MiniProfiler. We’ll if MiniProfiler blew you away, Glimpse is going to put you in Orbit!
The Glimpse Panel
From the HUD display, if we click on the Glimpse logo at the bottom right corner, the Glimpse panel is launched! This is not a browser plugin rather a dynamically injected CSS/JS panel full or metrics collected about your ASP.NET Application. Blown away yet?
Well, at first glance the data shown looks similar to what the Firebug plugin shows us, but there is a lot more than Firebug. Fact is Glimpse by the virtue of being on the Server and the Client, digs out way more data than Firebug and except for Request information, there is hardly any overlap. Of the default Tabs above, we will look at Configuration, Environment, Routes, Timeline, Trace and Views in details today.
With MVCs convention-over-configuration approach, a lot of times things work ‘magically’ and we are not sure about the exact mechanics. Glimpse serves as a valuable tool to see what is happening behind the scenes by unravelling how the conventions are interpreted.
The Configuration ‘tab’ pulls data out of our application’s Web.config as well as Machine.config. Essentially every configuration setting applicable to the app is pulled in. For example, above I see that once upon a time I had installed MySqlServer on my machine and it seems to have registered a provider on my system.
Among other things that it grabs, you can see the Custom Error settings, HTTP Modules and Handlers configured.
The environment gives us details of the Machine, Web Server, .NET Framework, Process ID as well as Assemblies in use among other things. For the assemblies loaded, it shows, version, culture, whether it’s from GAC and if they Full Trust.
The Routes tab shows us how the routing framework arrived at the route. Essentially it shows the success path traversed by the routing algorithm. For example in the snapshot below, we can see it tried to match the DefaultApi route, failed, skipped the next one that excludes axds and finally hit the successful route. If you have seen Phil Haack’s Route Debugger, this feature is similar.
The timeline feature breaks down the time required for the request to complete. There are actually two views, one a hierarchical view as follows
Second view is flattened and it’s a flattened out view. The Categories that are color coded can be unselected to show a filtered list.
What’s more interesting is that you have two markers that can be moved to select a smaller cross section of the categories to zoom-in.
This is probably the most insightful view for someone new to MVC. This shows how MVC selects a particular View. For a single request that has one partial view, we see how MVC queries the WebFormsViewEngine first and then the RazorViewEngine. It first searches the cache and if it doesn’t find it, the cache requests the view from the Disk, in green.
Essentially, the MVC view resolution code walks through all the View engines asking them if they were going to serve up the requested view.
As is the theme for all the tabs, the successful hit is highlighted
Finally we come to the Trace tab. This where custom tracing information is displayed. Custom as in explicit Trace statements that you may have writing the application. For example, if we update the Home Controller’s Index action method with the following trace statements:
public ActionResult Index()
System.Diagnostics.Trace.Write("Entered Index Action", "HomeController");
System.Diagnostics.Trace.TraceInformation("Adding some Trace Info", "HomeController");
System.Diagnostics.Trace.TraceWarning("Warning: May explode anytime");
ViewBag.Message = "Modify this template to jump-start your ASP.NET MVC application.";
The Trace Tab looks as follows:
So essentially all custom tracing info that we put is displayed in this tab, with helpful color coding based on the type of Trace.
The Glimpse Eco-System
Now that we have got a whiff of what Glimpse does, we must be wondering umm, what about tracing DB calls? For such an elaborate profiling system, surely there’s a way to database calls? Well, this is a good time to introduce you to the Glimpse Eco-System
Well this is only a partial list of the Extensions available. As we can see, we have EntityFramework, RavenDB, heck we even have an extension for Miniprofiler.
Profiling Entity Framework Database Calls
To get started with Database Profiling, when you use EF in your Data Layer is to install the correct version of the EF extension. In our case I installed EF5 from the Nuget Package Manager Console as follows:
PM> Install-Package Glimpse.EF5
Once installed, we run the application and navigate to TimeCard index page. We case that a new SQL tab has been added to the Glimpse panel. The following set of queries surprised me.
As you can see, there are two additional queries that I didn’t anticipate, on to the INFORMATION_SCHEMA and two to the __MigrationHistory table. These three are strictly EF related, and happen only on first run of the application. If you refresh the page, only the call to TimeCards table will be registered.
Security and Profiles in Glimpse
The information that Glimpse displays is potentially sensitive and should be ‘exposed’ very carefully. Inadvertent exposure of data like Connnection strings etc. can be disastrous from a security perspective. However, Glimpse is safe by default.
The Web.config’s Glimpse section is by default defined as follows:
The defaultRuntimePolicy=”On” sets up Glimpse to work locally ONLY. To disable this, we have to add an (commented out above) and add the Glimpse.AspNet.Policy.LocalPolicy assembly name.
However if we want to customize our policies, we could create a Custom Policy file as well. Glimpse very helpfully adds a commented out Class called GlimpseSecurityPolicy. The Execute method in this class receives the HTTP context and we can use the context to determine if Glimpse should be turned on or off for the given request. One example specified is to check if the given User is a part of the Administrator group and if not, turn off Glimpse.
Other Glimpse Features
Glimpse has this neat feature where it can track requesting clients. So if you have enabled Glimpse for multiple clients, you can sit at one browser and monitor the activities of the other browser. This can be ideally used for remote debugging. Combined with a Custom Policy we could create a ‘Debugger’ group in our ACL and add users who are having problems to the Debugger group if they have a problem. Then request them to reproduce the error at their end while you monitor the information thrown up by Glimpse for that user.
In the screenshot below, we have the hypothetical scenario where the second user is on a different machine using Firefox.
On our browser in IE, we click on the History tab to see there are two clients connected. When we click on Firefox, the data displayed switches to Firefox and we can see what’s going on at the other client.
That completes our round up of the hottest features of Glimpse. At this point, you should be sufficiently equipped to start poking around and inspecting your app with Glimpse.
Glimpse is truly an awesome addition to an ASP.NET developer’s toolbox. It provides deep insights into the working of an ASP.NET application without too many invasive code changes. Thanks to Redgate’s sponsorship, the project is placed well with project leaders devoting 100% of time to it. Over the last two years it has got impressive community support.
Today we primarily looked at the ‘out-of-the-box’ features. Someday in future we can investigate the extension points and how to add our own extensions to Glimpse.
Download the entire source code from our GitHub Repository at bit.ly/dncm7-gli