the open source diagnostics platform of the web

Category Archives: Release

Another month has gone by since our last release and this time round its a smallish one. Mostly bug fixes and a couple of usefully additions, but most of our time lately has been focused on v2.

By way of a small update on v2, we have almost finished the work we want to do on the backend and starting to look at the UI of v2. If you are interested in seeing exactly where things are at or seeing where you can get involved, feel free to take a look.

Getting back to the release, here is what we have this time around:Release Notes

Glimpse.Core – Featherweight release 1.8.4

Fix up edge case where UI would not be resizable

Extending the ContentTypeElement to include optional RuntimePolicy

Glimpse.ASP.NET – Bantamweight release 1.8.1

Update to RouteInspector to ignore non AspNet routes doesn’t work for WebHosted WebAPIs

Glimpse.EF* – Bantamweight release 1.6.1

Fixed bug when using DbGeography type in some edge cases

Special Thanks
In terms of pull requests, I have to say a big thanks to:

Its a new year and we have a new release ready to go out the door. This time around, we have a ton of bug fixes and a few new features here and there. This release represents the most contributions Glimpse has ever had in a single release, as well as having the greatest number of contributors.

WebForm support for DataBinding
Since our initial support for WebForms was released, the response from the community has been amazing. Not only have we discovered that WebForms developers have been seeking innovations in the space, but have been wanting to get involved. This has lead to Graham Mendick and Steve Ognibene stepping forward to make sure the WebForms package keeps moving forward.

This has lead to DataBinding visualization being added to the Control Tree tab within Glimpse. More details will com in a future blog post, but the short version is that we can now see all the actions that WebForms takes to bind your controls.

ASP.NET Server tab
In a previous release, we removed the old version of the Server tab. This was removed as a lot of the data we where displaying was being shown elsewhere. Since then, we have found that some users missed the data that wasn’t being displayed elsewhere. Hence, the Server tab has made a come back and has received a bit of a facelift thanks to Bryan Hogan.

Glimpse Insights support
Along with this release, we are putting out Glimpse Insights. As discussed in the post, this is the means by which we hope to better understand how people use Glimpse and where we should be focusing out efforts.

As much as we need these insights to make better decisions and ultimately a better product, if its something that you don’t want to take a part in, you can completely opt-out. Simply update the Glimpse section in your web.config to have the following addition:

If you do opt-out, there will be no traces of Insights in your code base. Insights was designed not simply to be a switch on or off, but to be a complete removal. Meaning no traces of the Insights code will remain if you choose to opt out.

Release Notes

Glimpse.Core – Featherweight release 1.8.2

Update to disabled Glimpse when request init is bypassed

Update client to only modify local ajax requests

Add initial support for Glimpse.WindowsAzure and Glimpse.WindowsAzure.Storage

Update to show friendly message if current async implementation is not supported

Added initial Insights support to client

Update client to delayed tab rendering till glimpse open

Update client to added more blacklist items for target chars that should be ignored by case processor

The community around Glimpse is continuing to swell as each release includes the effort of more and more people. This release is comprised almost entirely of contributions from outside the “founders team” of Anthony and I (who have been focusing much of our effort on the forthcoming release of version 2.0).

Caching Tab
The big feature in this release is the new Cache tab, which provides insight into the state of the application’s usage of data caching via the HttpRuntime.Cache object.

Async Patch
Additionally we have release a patch fix for a small number of users which have experienced problems with the Async support we released in 1.8.0 and crossing AppDomain boundaries. This has come up for users when they navigate to a page that contain a ReportViewer control, or using VS2010/12 Dev Web Server (instead of IIS Express or full IIS), or a couple of other edge cases.

A full fix for this will come in v2 but if you run into an exception that reads something similar to:

Type 'System.Web.HttpContextWrapper' in assembly 'System.Web, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a' is not marked as serializable.

In an effort not to leave too much time between releases, we happy to announce that as of today, Glimpse now supports capturing details that occur within Async operations. With the advent of .NET 4.5 it is easier than ever to take advantage of Async tasks to perform out-of-process or long running tasks.

Before now, Glimpse hasn’t been able to see the details of what occurs within these tasks, but with the help of the community, now we can! Unless you have specific needs, chances are the biggest difference you will see in your day-to-day usage of Glimpse, is that we can see everything that happens in Async queries that ADO/EF perform.

Release Notes

Glimpse.Core – Welterweight release 1.8.0

Support for capturing data on Async operations

Added Status Code to ajax and history tabs

Client now sensibly interpret friendly titles out of object keys

Client updated to render array lists as array of objects rather than array of arrays

Fixed bug where timeline couldn’t cope with long strings as the event title

Glimpse.ASP.NET – Welterweight release 1.6.0

Total rewrite of the Request tab to include additional request info

Removed Server tab as it’s now obsolete given the Request tab update

Glimpse.MVC* – Featherweight release 1.5.1

Fix version number inconsistency between MVC packages

Fix version information in MVC5

Glimpse.WebForms – Featherweight release 1.0.2

Greater support for many more control ViewState’s

Fixed circular reference bug that could be caused by some controls ViewState

Fixed bug which could cause trace output to be rendered in the page

Glimpse.ADO – Welterweight release 1.7.0

Support for Async queries

Added async indicator column to the SQL tab

Minor adjustment to the width of the transaction title column in SQL tab

Glimpse.EF* – Welterweight release 1.6.0

Support for Async queries

Added async indicator column to the SQL tab

Special Thanks
In terms of pull requests, I have to say a big thanks to:

Its been a while, but we have been hard at work version 2.0 (more on that later) and producing some new packages – which we are releasing TODAY! These new packages represent the first new packages we have released since Entity Framework support went out the door in March and I think you are in for a real treat.

We have released two new packages today and a bunch of other minor features/fixes. Here are the highlights:

Glimpse.WebForms Released:

Amazing ViewState support

New Control Tree and Page Life Cycle Tabs

Deep HUD integration

Glimpse.MVC5 Released:

All the tabs you previously had with MVC4

Support for attribute driven routes

WebForms support

Glimpse.WebForms is a revolutionary step forward in the way we will work with WebForms in the future. For years, many have struggled to understand how WebForms works, what is responsible for ViewState bloat or if you even have a ViewState issue. As of today, we finally have the tools we need to know exactly how WebForms is running and what is responsible for problems we may be experiencing.

ViewState Reimagined
We have taken a crack at totally re-imagining what we have come to expect when working with ViewState.

As you can see, without any ceremony, Glimpse shows you all of your controls and the ViewState that each control has generated. This is insight, that until now, we have only been able to dream about.

Current Pain:
For most, understanding/controlling ViewState has always been a struggle. When we think about ViewState, most think about a hidden input in our HTML that contains a blob of text which does something for our site.

Mostly, when its running smoothly, ViewState isn’t one of those concerns that we think about every day. But at some point, we discover that amount of data being sent down to the page in ViewState growing out of control – ViewState bloat.

Solution Seeking:
When this occurs we typically turn to Google, which brings up a trusty StackOverflow article that will give us the answer of where to start – Seeking advice on de-bloating asp.net 3.5. Unfortunately though, the top answer is to:

“Try ASP.NET MVC or one of the other MVC web frameworks for .NET”

For most this is a very unhelpful and disappointing answer. Not everyone has the “luxury” to rewrite their whole site just to solve this one problem.

ViewState De-coders:
So, after some more searching we discover that there is a way of taking the ViewState text and running it through a de-coder:
At first glance, we think we are getting somewhere, but we soon discover that we have no idea what the data means or what control is responsible for generating it. Note: all this assumes that we aren’t running out WebForms site in .NET 4.5, as ViewState is now encrypted. Hence, making the only tools we had useless.

Enter Glimpse!
Glimpse is in a unique position to try and solve many of the problems we have around ViewState. Since we run on the server, we are able to see the ViewState before it is encrypted and we are even able to determine which server control generated the state.

Here is a specific example of what Glimpse is able to bring to the table:

1) Master Page State, 2) Cart Count State and 3) List View State

vs.

1) Master Page State

2) Cart Count State

3) List View State

Strongly Typed ViewState:
When looking at the above screen shots of Glimpse, its easy to miss the way in which we display the data. As it turns out the ViewState object model is designed for the systems to process (not humans) and is optimised for minimum payload size. Hence, if we don’t perform any additional logic, the below is what you would see:

“Untyped ViewState data”

When looking at this, you’d be easily forgiven for finding it better than what a decoder provides (since we know what ViewState belongs to what controls), but it still doesn’t match our mental model of what we think the data should look like.

Hence, we decided to take a crack at making that better too. We discovered that since we know which server control generated the ViewState, we are able to present the data in a format that “strongly types” it on a control by control basis. This technique changes the output we can show you dramatically. Resulting in the below:

No more guessing:
With the advent of this capability, you will no longer have to guess what controls generated which ViewState data. Glimpse makes this completely transparent and understandable to everyone.

Control Tree
As you would have guessed by looking at the above screenshots, we are able to present you the Control Tree Hierarchy as well. This structure is used by the WebForms framework to generate the HTML that you see on your page. This may look familiar from the Trace.axd days, but as discussed above, Glimpse has taken it up a notch.

Here is a list of what we show you out of the box:

Control Id: This is the server-side ID that is generated by the framework for your control. If you specifically set an ID, then the system will display that name instead.

Type: The system Type of the rendered control.

Render (w/ children): The size in bytes of the HTML generated by the control and its children.

ViewState: The size in bytes of the ViewState generated directly by the control.

ControlState: The size in bytes of the ControlState generated directly by the control.

Page Life Cycle
In sites using WebForms, the page life cycle is a series of events which fire on every page and has a very defined sequence. As fate would have it, its one of those things that we rarely remember exactly how and when they are supposed to execute. Glimpse makes this transparent by showing you which events occurred, their timings and offsets.

Here is what we show you out of the box:

Trace Tab:
Beyond showing these events in the Page Life Cycle tab, we automatically trace out the Begin and End notifications for each event to the Trace Tab. This means that when ever you write out data via either of the following methods, it will show up between the relevant Page Life Cycle trace messages:System.Diagnostics.Trace.Write("This is a trace Message");
orSystem.Web.HttpContext.Current.Trace.Write("This is another trace Message");

With that, here is the final result:

Timeline Tab:
Besides just adding this data to the Trace tab, we have included the events within the timeline tab. This means that when you have other timing events (like database access) occurring, you will be able to visual see exactly what is happening.

WebForms in HUD
If all this wasn’t enough, we decided to make sure the most important ViewState and Page Life Cycle data be shown within HUD (heads up display).

HUD is specifically designed to stay at the bottom of every page and stick with you as you go about your normal development effort. Taking this into account we show you the following out of the box, without having to click, mouseover or select anything:

Load: Time between Begin PreLoad and End LoadComplete.

Render: Time between Begin PreRender and End Render (including SaveState events).

ViewState: Total size in bytes that the page has stored as ViewState.

If you are used to the Glimpse.MVC packages, the Load and Render times are similar to the Action and View times that we show you. But for those who use ViewState, knowing exactly what each page is generating within HUD is huge. This one figure alone is invaluable, let alone the rest of what this package brings.

HUD popup view
HUD also allows us to show a more detailed view of the most important information we have in the form a popup that appears when you mouse over a section. For WebForms, we have taken advantage of this to show a contextual view of the Page Life Cycle information along with any database activity you may have performed.

Beyond seeing what we saw in the mini view, we have added the Page Life Cycle events and included exactly different database events have occurred. This allows you to see straight away what events are taking the longest and what queries are occurring where. Prior to Glimpse.Webforms, building this picture was virtual impossible.

MVC5 support

The other package we are releasing today is Glimpse.MVC5. This is an incremental release for MVC and designed to match the latest release of ASP.NET MVC. With this release, you will get all the usual goodness you have come to expect from Glimpse.MVC*. The release also contains support for the new attribute driven routing that MVC5 brings to the table.

Attribute Drive Routing

Glimpse Route Tab

Release Notes

Beyond everything I have already covered in the above, this release includes a number of updates and fixes for a variety of issues. This release contains updates to following packages:

Glimpse.Core – Welterweight release 1.7.0

Improvement which allows Glimpse.axd to be protected by custom security policies

Fix History tab causing issues when invalid characters are present in a Session Name

Performance improvement Ensure client shell is forced into a new rendering layer within browser

Update Visual Studio solution to VS2013

Improvement to client which adds support for paddings when rendering structured layouts

Improvement to client to make array rendering more resilient

Improvement to client which ensures table headers have the correct default style applied

Release 1.6.0 has been out for a little over a month now and so far so good. Generally speaking, our stability over the past few months has been pretty good and as a result we are starting to feel that Glimpse v1 is nearing an end and v2 is on the horizon! but more to come on that in the future 😀

In the mean time we noticed that the issue backlog has been building up and wanted to go on a bug bashing excises. Hence, we have been spending time knocking down out issues. We managed to get out outstanding issue count down from around 110 to under 40. As you might imagine, this has resulted in some updates and hence this release.

Hence, this release is a service update to fix a variety of issues. This release sees updates to following packages:

Since going live with 1.4.0, the feedback has been amazing. We have heard from many different people that the way in which HUD represents the data really resonates with what people are after and servers a general need – rather than just the cool factor.

This release is a service update to fix some edge cases that people have come across. This release sees updates to following packages:

Glimpse.Core – Lightweight release 1.4.2

Bug fix on the back end to prevent ajax results that return Json causing errors

Bug fix in the client which prevents a possible race condition from occurring between when HUD can detect Ajax requests and when it can display them

Minor fix to client to prevent host event data from overflowing in some cases

Minor optimization improvement in the client to prevent it from calling out when either the ajax/history tab is selected and the client is closed

Glimpse.MVC* – Lightweight release 1.3.2

Minor fix to client to only render Action/View timings if that information is available

This release is a very small release and just fixing up a couple of issues we came across after releasing 1.4.0.

The main issue in this release is the fact that within the MVC package, async controller action events were being classified as Filter events rather than Controller events. This was causing the HUD client to throw an exception when this case occurred.

To get this fix you will need to update to Glimpse.Core 1.4.1 and Glimpse.MvcX 1.3.1.

Isn’t it amazing that these days we have the luxury of time to have a release where all we do is fix issues and take great pull requests. It turns out that this is one of those times with the release of 1.3.1.

This release sees updates to following packages:

Glimpse.Core – Welterweight release

Majorish fix that addresses the new Glimpse.axd page telling you that a new update is available even though you just updated

Majorish update which switches cache busting control from client with query string to the server using the correct headers

Majorish fix for users getting duplicate resource error message

Minor fix where popup window not resizing viewable area for timeline

Minor update to allow FileResource to be used outside of Glimpse.Core

Minor fix for NuGetAttribute which ignores constructor arguments

Minor fix for multi-threaded tracing regression

Glimpse.AspNet – Flyweight release

Minorish update to Session Tab to support for objects which override the ToString method