Built in profiling

ServiceStack's HTML5 JSON Report Format also includes the excellent Mvc Mini Profiler - by @jarrod_dixon and @samsaffron. It's the same profiler used to profile and help speed up sites like Stack Overflow and more recently the much faster NuGet v2.0 website.

As the MVC Mini Profiler is optimized for a .NET 4.0 MVC app, we've made some changes in order to integrate it into ServiceStack:

• Make it work in .NET 3.0 by backporting .NET 4.0 classes into ServiceStack.Net30 namespace (Special thanks to OSS! :)
  • Using Mono's ConcurrentDictionary classes
  • Using Lokad.com's Tuples
• Switched to using ServiceStack's much faster Json Serializer
• Reduced the overall footprint by replacing the use of jQuery and jQuery.tmpl with a much smaller jquip (jQuery-in-parts) dependency.
• Moved to the ServiceStack.MiniProfiler namespace and renamed to Profiler to avoid clashing with another Mvc Mini Profiler in the same project

As a side-effect of integrating the Mvc Mini Profiler all ServiceStack .NET 3.0 projects can make use of .NET 4.0's ConcurrentDictionary and Tuple support, hassle free!

Using the MVC Mini Profiler

Just like the Normal Mvc Mini Profiler you can enable it by starting it in your Global.asax, here's how to enable it for local requests:

protected void Application_BeginRequest(object src, EventArgs e)
{
    if (Request.IsLocal)
	Profiler.Start();
}

protected void Application_EndRequest(object src, EventArgs e)
{
    Profiler.Stop();
}

That's it! Now everytime you view a web service in your browser (locally) you'll see a profiler view of your service broken down in different stages:

By default you get to see how long it took ServiceStack to de-serialize your request, run any Request / Response Filters and more importantly how long it took to Execute your service.

The profiler includes special support for SQL Profiling that can easily be enabled for OrmLite and Dapper by getting it to use a Profiled Connection using a ConnectionFilter:

this.Container.Register<IDbConnectionFactory>(c =>
	new OrmLiteConnectionFactory(
		"~/App_Data/db.sqlite".MapHostAbsolutePath(),
		SqliteOrmLiteDialectProvider.Instance) {
			ConnectionFilter = x => new ProfiledDbConnection(x, Profiler.Current)
		});

Refer to the Main MVC MiniProfiler home page for instructions on how to configure profiling for Linq2Sql and EntityFramework.

It's also trivial to add custom steps enabling even finer-grained profiling for your services. Here's a simple web service DB example returning a list of Movies using both a simple DB query and a dreaded N+1 query.

public class MiniProfiler
{
	public string Type { get; set; }
}

public class MiniProfilerService : ServiceBase<MiniProfiler>
{
	public IDbConnectionFactory DbFactory { get; set; }

	protected override object Run(MiniProfiler request)
	{
		var profiler = Profiler.Current;

		using (var dbConn = DbFactory.OpenDbConnection())
		using (var dbCmd = dbConn.CreateCommand())
		using (profiler.Step("MiniProfiler Service"))
		{
			if (request.Type == "n1")
			{
				using (profiler.Step("N + 1 query"))
				{
					var results = new List<Movie>();
					foreach (var movie in dbCmd.Select<Movie>())
					{
						results.Add(dbCmd.QueryById<Movie>(movie.Id));
					}
					return results;
				}
			}

			using (profiler.Step("Simple Select all"))
			{
				return dbCmd.Select<Movie>();
			}
		}
	}
}

Calling the above service normally provides the following Profiler output:

Whilst calling the service with the n1 param yields the following warning:

In both cases you see the actual SQL statements performed by clicking the SQL link. The N+1 query provides shows the following:

Notice the special attention the MVC MiniProfiler team put into identifying Duplicate queries - Thanks Guys!