Telerik has released the Q3 2013 release of JustTrace, which is available here! JustTrace has always been a great and easy to use tool for tracing and profiling your applications, but this new release has some great new features that make this great tool even better! A major strength of JustTrace is that we provide a one-click way to find common problems in .NET applications. You’ll see that we bring the exact same ease of use to our new features that we’ve built into JustTrace all along. This makes JustTrace the best tool to quickly find the issues in your .NET application.
Source Level Profiling
A problem with application prowling, especially for those new to it, is being able to understand how to interpret the data. A profiler will tell you if your code is running slow, but odds are if you’re using a profiler you already have concerns about your applications performance. Sometimes it’s difficult to figure out why it is slow. Well, this just got easier! The latest version of JustTrace features source level profiling! What does this mean? To demonstrate this, I profiled an application that computes a Mandelbrot fractal. Once the application completed, JustTrace showed me the Call Tree for all the threads (Figure 1):
Figure 1 – All Threads
As I can see here, my call to MandelbrotWindow.CreatePalette is taking a high percentage of my applications time (39.42%). Looking at this I think it’s safe to say that my problem is probably somewhere in that method. With source level profiling, I can drill down into my code and see exactly, to the line of code, where my problem is (Figure 2):
Figure 2 – The line of code causing the problem
I can see that this one line of code (highlighted in red) is taking 85.45% of my time. This line is likely the culprit. I happen to be able to fix this particular problem by moving this line of code out of the outermost for loop (line 116). I’ll make this change, then profile my application again (Figure 3):
Figure 3 – Profiling after the change
As I can see in the Total Time for the application process, the execution time went from 195,569 ms to 25,638 ms. That one misplaced line of code was causing a huge performance hit, but JustTrace was able to find it, enabling me to fix the problem.
Accessing external resources can be slow. The most common external resources developers have to deal with are databases. Database calls can be slow, and if you query is sub-optimal, it can really put a major dent in the performance of your application. When a performance issue strikes our application most developers start looking at their code for the problem. Most developers don’t think about the SQL that our applications are using and how it affects performance. To help with this problem, JustTrace now has SQL Profiling.
SQL Profiling works very similarly to a lot of the other types of profiling in JustTrace. When you profile an application you’ll see you SQL query in the All Threads view of the Call Tree (Figure 4):
Figure 4 – A SQL Query in the call tree
This view provides me some information about my query, including where it was called from and its hit count. If I need more detailed information about my SQL query, specifically what the query was, I can view in the SQL Queries section of the Methods group (Figure 5):
Figure 5 – I can see what my SQL query is
It’s great to be able to see how long the SQL query took; it can identify performance issues we would have otherwise missed. Being able to see the query can be crucial in fixing the issue. Many developer have moved to ORMs for data access. We take it on faith that these frameworks emit good SQL. But that’s not always the case. JustTrace is now able to help you find the situations where your ORM is coming up short and enable you to tackle the real problem instead of trying to address the perceived symptoms. And this feature supports every database that has an ADO.NET driver, which means that most databases and ORMs are supported out of the box!
Profiling HTTP Requests
If you’ve ever developed and deployed a web application, at some point you’ve no doubt had complaints about performance. By their nature, web applications are dependent on a network, and thus effected by traffic on that network. When instances of poor performance are reported it can sometimes be difficult to determine if your application is at fault, or a victim of network latency.
But that’s not the only transport imposed challenge facing web developers. HTTP is not a type-safe protocol. When a client sends data in an HTTP request that your application can’t understand it can result in errors that are difficult to diagnose with traditional debugging methods. If you’ve ever developed a web service (especially a public facing one) you have likely encountered this type of issue at some point, and without the right tools they can be difficult to iron out.
JustTrace now has the ability to profile HTTP Requests, which can help you diagnose and address both of these issues. Just like SQL Queries, HTTP Requests will appear in your normal call tress just like any other method (Figure 6):
Figure 6 – the HTTP Request in the Call Tree
From here I can see how long my web application takes to fulfill the client’s request. If I have clients that are experiencing performance issues this will help you determine if it is your application or the network that is the problem, enabling you to be sure you’re attacking the right issue and not guessing.
If I need to see the details of the request, I can click on the ASP.NET Requests section of the Methods group and see the detailed information for the HTTP Request (Figure 7):
Figure 8 – Detailed HTTP Request information
With this view I can see exactly what my HTTP request looks like, including cookie and server information. If I’m receiving a malformed request or something I’m not expected I can find it easily with this view.
In addition to seeing the incoming HTTP requests, but clicking on the “Outgoing Web Requests” section of the “Methods” group I can see outgoing HTTP requests from my application. This not only ensures that I’m finding issues with my incoming traffic, but ensures that I’m using external HTTP based resources efficiently as well.
There are some exciting new features in the Q3 2013 release of JustTrace and this post just scratches the surface. Look for detailed posts in the near future showing how to use these new features to make your development life much easier! To see a list of all the new features in JustTrace check out our “What’s New” page and don’t forget to register for Webinar week!