用于 .Net 6 的带有 MiniProfiler 的 ServiceStack

Question

I was attempting to add Profiling into ServiceStack 6 with .Net 6 and using the .Net Framework MiniProfiler Plugin code as a starting point.

I noticed that ServiceStack still has Profiler.Current.Step("Step Name") in the Handlers, AutoQueryFeature and others.

What is currently causing me some stress is the following:

1. In ServiceStackHandlerBase.GetResponseAsync(IRequest httpReq, object request) the Async Task is not awaited. This causes the step to be disposed of the when it reaches the first async method it must await, causing all the subsequent nested steps to not be children. Is there something simple I'm missing here or is this just a bug in a seldom used feature?
2. In SqlServerOrmLiteDialectProvider most of the async methods make use of an Unwrap function that drills down to the SqlConnection or SqlCommand this causes an issue when attempting to wrap a command to enable profiling as it ignores the override methods in the wrapper in favour of the IHasDbCommand.DbCommand nested within. Not using IHasDbCommand on the wrapping command makes it attempt to use wrapping command but hits a snag because of the forced cast to SqlCommand . Is there an easy way to combat this issue, or do I have to extend each OrmliteDialectProvider I wish to use that has this issue to take into account the wrapping command if it is present?

Any input would be appreciated.

Thanks.

---

Extra Information Point 1

Below is the code from ServiceStackHandlerBase that appears (to me) to be a bug?

public virtual Task<object> GetResponseAsync(IRequest httpReq, object request)
{
    using (Profiler.Current.Step("Execute " + GetType().Name + " Service"))
    {
        return appHost.ServiceController.ExecuteAsync(request, httpReq);
    }
}

I made a small example that shows what I am looking at:

using System;
using System.Threading.Tasks;
                    
public class Program
{
    public static async Task<int> Main(string[] args)
    {
        Console.WriteLine("App Start.");
        
        await GetResponseAsync();
        
        Console.WriteLine("App End.");
        return 0;
    }
    
    // Async method with a using and non-awaited task.
    private static Task GetResponseAsync()
    {
        using(new Test())
        {
            return AdditionAsync();
        }
    }
    
    // Placeholder async method.
    private static async Task AdditionAsync()
    {
        Console.WriteLine("Async Task Started.");
        
        await Task.Delay(2000);
        
        Console.WriteLine("Async Task Complete.");
    }
}

public class Test : IDisposable 
{
    public Test() 
    {
        Console.WriteLine("Disposable instance created.");
    }

    public void Dispose() 
    {
        Console.WriteLine("Disposable instance disposed.");
    }
}

My Desired Result:

App Start.
Disposable instance created.
Async Task Started.
Async Task Complete.
Disposable instance disposed.
App End.

My Actual Result:

App Start.
Disposable instance created.
Async Task Started.
Disposable instance disposed.
Async Task Complete.
App End.

This to me shows that even though the task is awaited at a later point in the code, the using has already disposed of the contained object.

Answer 1

Mini Profiler was coupled to System.Web so isn't supported in ServiceStack .NET6 .

To view the generated SQL you can use a BeforeExecFilter to inspect the IDbCommand before it's executed.

This is what PrintSql() uses to write all generated SQL to the console:

OrmLiteUtils.PrintSql();

Note: when you return a non-awaited task it just means it doesn't get awaited at that point, it still gets executed when the return task is eventually awaited.

To avoid the explicit casting you should be able to override a SQL Server Dialect Provider where you'll be able to replace the existing implementation with your own.