Loupe 4.0 Beta 3 - Enhanced Application User capture, auto-deploying extensions and new Windows client options
When we published Beta 2 we knew we were leaving some items unaddressed - a host of non-critical defects, packaging and deployment items, and we’d disabled Loupe AddIns because they were in mid-flight. Now, six weeks later, we’ve covered that and have a release candidate build in our hands. Why then are we calling it a Beta? Because we’re waiting on final customer feedback on the new extensibility and Agent API changes. If you’re not current on all of the features coming in Loupe 4.0, you should check out what we talked about in Beta 2 and Beta 1.
Auto-Deploying Extensions
For Loupe 4.0 we’ve renamed Loupe Addins to Extensions and significantly updated the model. When we first created the AddIn model Loupe Server didn’t even exist, so it was designed primarily as a way of extending the Loupe Desktop UI. Since most Loupe installations were small deployment wasn’t a significant consideration. Fast forward to 2015 and things are quite different. Nearly 100% of on-premises Loupe Server customers have developed their own custom extensions. When they want to extend the Loupe Desktop UI they have to hand-deploy it which is error prone and a significant barrier to adoption. Loupe Server Enterprise Edition lets customers bring together multiple servers to share the load, requiring extensions be synchronized between them.
The original AddIn system has another Achilles heal: It was designed with the assumption that there is just one repository. Loupe 3.7 changed all that: Now you can connect to multiple repositories from Loupe Desktop at the same time. Loupe 4.0 takes that even further. For version 3.7, none of the additional repositories support addins. That just wasn’t going to fly in 4.0. To address this, we’ve changed the way Loupe gets extended to emphasize ease of deployment, particularly for Enterprise customers, and support multiple repositories at the same time with independent configuration for each server repository.
It’s NuGet All the Way Down
NuGet entered the scene well after the original creation of Loupe AddIns, but it’s ready to go now. For Loupe 4.0, each extension is a NuGet package. The server installation has a NuGet server that each server and client connect to, automatically getting the latest version of each extension when they start. This provides a well understood metadata, packaging, and versioning strategy. Deploying a new version of an extension is now simple - create the package and register it with the server. Then, each computer in the installation will fetch that new version the next time it initializes extensions. Rollback is just as easy - remove the package and it’ll fall back to the previous version.
Configuration by Repository
All of the extension configuration is now associated with a single server repository. We’ve extended the older configuration model to recognize that users move between computers quickly, so user configuration needs to be synchronized with the server repository and automatically sent down to a Windows client as required. Within Loupe Desktop each repository gets its own list of enabled extensions and configuration independence. So, if one team needs to integrate with TFS and another with a custom internal system that’s no problem.
Enhanced Application User Information
In Beta 2 we talked about how it’s all about the user but there’s only so much we can get by parsing the user name. What if you wanted to add more data? For example, most web applications that authenticate users have a display name, an email address, and possibly more. We needed a way to get that information to the server.
We’ve done this by adding a new event for translating the user name key into its full data. Here’s what the code looks like in the Loupe web UI itself:
We simply subscribe this event handler to the Log.ResolveApplicationUser event and each time the agent comes across a user principle it hasn’t resolved yet it gets raised, giving us the opportunity to give it more information. This is done asynchronously from the individual threads of your application so it won’t slow them down. This information then gets fully integrated into the web UI and even shows in Loupe Desktop.
New Windows Client Options
Speaking of Loupe Desktop, we’ve got some changes there too. In addition to adding new features, we’ve created a new dedicated installation for Loupe Desktop. This new smaller installation is designed so you can install the Windows client directly from your Loupe Server. You then receive updates directly from your server. This helps self-hosted Loupe customers better control their own deployments and makes it easier for new users to find the Windows client if they want it.
This is all part of our new strategy for Loupe 4.0 we call Server First. The goal is to emphasize to new users how to get the most out of Loupe using the server’s UI first and then extend into the native Windows client later. This lets users start where they expect: Most application monitoring systems do everything through their web UI so we’re finding that new users expect to start there. Loupe is unique in having a deep Windows client which we truly believe every developer will want, but we’ve found that most folks don’t want to start there. As part of this strategy we’ve added new prescriptive guidance into the Your Loupe Dashboard and now ship the entire help documentation as part of the web UI as well. The bottom line is that your Loupe Server has every resource you need to get the most out of Loupe!
More Agent Enhancements
This is the first build of Loupe 4.0 that includes an updated agent. In addition to the new Application User functionality, we’ve added some key features that folks have requested. If you’d like to try the new Loupe 4.0 agent, it’s published to NuGet as a beta package so you’ll need to enable prerelease versions in your package manager.
Specify Agent Configuration without an Event
Some environments, notably scripting ones like PowerShell, do not handle events well. Having to subscribe to an event handler to specify configuration makes it very difficult to use Loupe in these cases. Now you can specify configuration in code by building up a configuration object and passing it to Log.StartSession. This works well in a number of other cases where your have confidence you’ll be calling StartSession to explicitly kick off logging.
Load Agent Configuration from File
You can now save and load a configuration from a file. This feature has been requested by several customers to make it easier for them to share a common, isolated Loupe configuration between projects. The file format and options are identical to how Loupe extends the web.config/app.config files but can be isolated in its own file without requiring any changes to the web.config/app.config.
Flexible Customized Session Selection for Packaging and Server Integration
We’ve traditionally offered a very simple enumeration-based approach to specifying what sessions should be included in a package or sent to a server. This works quite well for most user scenarios but we’ve had folks request to do something more interesting and unique. Now you can specify a custom predicate to evaluate the session summary information and decide whether to include a session or not, enabling virtually any selection approach you might think of. Most people won’t need this, but if you’ve got some interesting edge case in mind, you’re covered.
Get Loupe 4.0 Now
This version has gone through a considerable amount of testing and use, and is supported by us. If you run your own Loupe Server, you can upgrade to this version and from here to the final 4.0 version when it ships. From here to release, we’re doing documentation updates and waiting for final feedback from our beta community. Once we’ve got the final details sorted, we’ll publish 4.0 - likely within a few weeks. Read the full release notes and download 4.0 Beta 3!