Add MessageInterceptor and connection closing hooks

Author: pwelter34

.github/dependabot.yml

@@ -17,8 +17,6 @@ updates:
     open-pull-requests-limit: 10
     ignore:
       - dependency-name: "Microsoft.CodeAnalysis.CSharp"
-      - dependency-name: FluentAssertions
-        versions: [">=8.0.0"]
     groups:
       Azure:
         patterns:

src/FluentCommand.SqlServer/DataConfigurationBuilderExtensions.cs

@@ -23,4 +23,18 @@ public static DataConfigurationBuilder UseSqlServer(this DataConfigurationBuilde
 
         return builder;
     }
+
+    /// <summary>
+    /// Configures the <see cref="DataConfigurationBuilder"/> to capture SQL Server informational messages such as PRINT output.
+    /// </summary>
+    /// <param name="builder">The data configuration builder to configure.</param>
+    /// <returns>
+    /// The same <see cref="DataConfigurationBuilder"/> instance so that multiple calls can be chained.
+    /// </returns>
+    public static DataConfigurationBuilder CaptureMessages(this DataConfigurationBuilder builder)
+    {
+        builder.AddInterceptor<MessageInterceptor>();
+
+        return builder;
+    }
 }

src/FluentCommand.SqlServer/MessageInterceptor.cs

@@ -0,0 +1,68 @@
+using System.Data.Common;
+
+using Microsoft.Data.SqlClient;
+using Microsoft.Extensions.Logging;
+
+namespace FluentCommand;
+
+/// <summary>
+/// Captures SQL Server informational messages such as PRINT output.
+/// </summary>
+/// <seealso cref="IDataConnectionInterceptor" />
+public class MessageInterceptor : IDataConnectionInterceptor
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MessageInterceptor"/> class.
+    /// </summary>
+    /// <param name="logger">The logger.</param>
+    public MessageInterceptor(ILogger<MessageInterceptor> logger)
+    {
+        Logger = logger ?? throw new ArgumentNullException(nameof(logger));
+    }
+
+    /// <summary>
+    /// Gets the logger.
+    /// </summary>
+    protected ILogger Logger { get; }
+
+    /// <inheritdoc />
+    public virtual void ConnectionOpened(DbConnection connection, IDataSession session)
+    {
+        if (connection is SqlConnection sqlConnection)
+            sqlConnection.InfoMessage += OnInfoMessage;
+    }
+
+    /// <inheritdoc />
+    public virtual Task ConnectionOpenedAsync(DbConnection connection, IDataSession session, CancellationToken cancellationToken = default)
+    {
+        ConnectionOpened(connection, session);
+        return Task.CompletedTask;
+    }
+
+    /// <inheritdoc />
+    public virtual void ConnectionClosing(DbConnection connection, IDataSession session)
+    {
+        if (connection is SqlConnection sqlConnection)
+            sqlConnection.InfoMessage -= OnInfoMessage;
+    }
+
+    /// <inheritdoc />
+    public virtual Task ConnectionClosingAsync(DbConnection connection, IDataSession session, CancellationToken cancellationToken = default)
+    {
+        ConnectionClosing(connection, session);
+        return Task.CompletedTask;
+    }
+
+    /// <summary>
+    /// Handles SQL Server informational messages.
+    /// </summary>
+    /// <param name="sender">The event source.</param>
+    /// <param name="e">The SQL Server message event data.</param>
+    protected virtual void OnInfoMessage(object sender, SqlInfoMessageEventArgs e)
+    {
+        if (e is null)
+            return;
+
+        Logger.LogInformation("SQL Server message: {Message}", e.Message);
+    }
+}

src/FluentCommand/DataSession.cs

@@ -286,6 +286,9 @@ public void ReleaseConnection()
 
         // When no operation is using the connection and the context had opened the connection
         // the connection can be closed
+        foreach (var interceptor in _connectionInterceptors)
+            interceptor.ConnectionClosing(Connection, this);
+
         Connection.Close();
         _openedConnection = false;
     }
@@ -309,6 +312,9 @@ public async Task ReleaseConnectionAsync()
 
         // When no operation is using the connection and the context had opened the connection
         // the connection can be closed
+        foreach (var interceptor in _connectionInterceptors)
+            await interceptor.ConnectionClosingAsync(Connection, this).ConfigureAwait(false);
+
         await Connection.CloseAsync().ConfigureAwait(false);
         _openedConnection = false;
     }
@@ -324,6 +330,14 @@ protected override async ValueTask DisposeResourcesAsync()
         if (Transaction is not null)
             await Transaction.DisposeAsync().ConfigureAwait(false);
 
+        if (_openedConnection)
+        {
+            foreach (var interceptor in _connectionInterceptors)
+                await interceptor.ConnectionClosingAsync(Connection, this).ConfigureAwait(false);
+
+            _openedConnection = false;
+        }
+
         await Connection.DisposeAsync().ConfigureAwait(false);
     }
 #endif
@@ -337,6 +351,15 @@ protected override void DisposeManagedResources()
             return;
 
         Transaction?.Dispose();
+
+        if (_openedConnection)
+        {
+            foreach (var interceptor in _connectionInterceptors)
+                interceptor.ConnectionClosing(Connection, this);
+
+            _openedConnection = false;
+        }
+
         Connection.Dispose();
     }
 

src/FluentCommand/FluentCommand.csproj

@@ -14,6 +14,6 @@
     <PackageReference Include="System.ComponentModel.Annotations" Condition="'$(TargetFramework)' == 'netstandard2.0'" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="..\FluentCommand.Generators\bin\$(Configuration)\netstandard2.0\FluentCommand.Generators.dll" PackagePath="analyzers/dotnet/roslyn4.8/cs" Pack="true" Visible="false" />
+    <None Include="..\FluentCommand.Generators\bin\$(Configuration)\netstandard2.0\FluentCommand.Generators.dll" PackagePath="analyzers/dotnet/cs" Pack="true" Visible="false" />
   </ItemGroup>
 </Project>

src/FluentCommand/IDataConnectionInterceptor.cs

@@ -25,5 +25,27 @@ public interface IDataConnectionInterceptor : IDataInterceptor
     /// <param name="session">The <see cref="IDataSession"/> that opened the connection.</param>
     /// <param name="cancellationToken">The cancellation instruction.</param>
     /// <returns>A task representing the asynchronous operation.</returns>
-    Task ConnectionOpenedAsync(DbConnection connection, IDataSession session, CancellationToken cancellationToken = default);
+    Task ConnectionOpenedAsync(
+        DbConnection connection,
+        IDataSession session,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Called immediately before a database connection is closed.
+    /// </summary>
+    /// <param name="connection">The <see cref="DbConnection"/> that is about to be closed.</param>
+    /// <param name="session">The <see cref="IDataSession"/> that opened the connection.</param>
+    void ConnectionClosing(DbConnection connection, IDataSession session);
+
+    /// <summary>
+    /// Called immediately before a database connection is closed asynchronously.
+    /// </summary>
+    /// <param name="connection">The <see cref="DbConnection"/> that is about to be closed.</param>
+    /// <param name="session">The <see cref="IDataSession"/> that opened the connection.</param>
+    /// <param name="cancellationToken">The cancellation instruction.</param>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    Task ConnectionClosingAsync(
+        DbConnection connection,
+        IDataSession session,
+        CancellationToken cancellationToken = default);
 }

test/FluentCommand.SqlServer.Tests/DataInterceptorTests.cs

@@ -1,6 +1,7 @@
 using System.Data.Common;
 
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 
 namespace FluentCommand.SqlServer.Tests;
 
@@ -23,6 +24,8 @@ public void WhenConnectionOpened_ConnectionInterceptorCalledOnce()
 
         interceptor.ConnectionOpenedCount.Should().Be(1);
         interceptor.ConnectionOpenedAsyncCount.Should().Be(0);
+        interceptor.ConnectionClosingCount.Should().Be(1);
+        interceptor.ConnectionClosingAsyncCount.Should().Be(0);
     }
 
     [Fact]
@@ -34,10 +37,12 @@ public async Task WhenConnectionOpenedAsync_ConnectionInterceptorCalledOnce()
         await using var session = new DataSession(config.CreateConnection(), interceptors: [interceptor]);
 
         await session.EnsureConnectionAsync(TestCancellation);
-        session.ReleaseConnection();
+        await session.ReleaseConnectionAsync();
 
         interceptor.ConnectionOpenedAsyncCount.Should().Be(1);
         interceptor.ConnectionOpenedCount.Should().Be(0);
+        interceptor.ConnectionClosingAsyncCount.Should().Be(1);
+        interceptor.ConnectionClosingCount.Should().Be(0);
     }
 
     [Fact]
@@ -54,6 +59,7 @@ public void WhenEnsureConnectionCalledTwice_ConnectionInterceptorCalledOnce()
         session.ReleaseConnection();
 
         interceptor.ConnectionOpenedCount.Should().Be(1);
+        interceptor.ConnectionClosingCount.Should().Be(1);
     }
 
     [Fact]
@@ -144,11 +150,27 @@ public void WhenCreatedWithNoInterceptors_SessionExposesEmptyList()
         session.Interceptors.Should().BeEmpty();
     }
 
+    [Fact]
+    public void WhenSqlPrintExecuted_PrintMessageIsLogged()
+    {
+        var config = Services.GetRequiredService<IDataConfiguration>();
+        var logger = new TrackingLogger<MessageInterceptor>();
+        var interceptor = new MessageInterceptor(logger);
+
+        using var session = new DataSession(config.CreateConnection(), interceptors: [interceptor]);
+
+        session.Sql("PRINT 'fluent command print message'; SELECT 1").QueryValue<int>().Should().Be(1);
+
+        logger.Messages.Should().Contain(m => m.Contains("fluent command print message", StringComparison.Ordinal));
+    }
+
 
     private sealed class TrackingConnectionInterceptor : IDataConnectionInterceptor
     {
         public int ConnectionOpenedCount { get; private set; }
         public int ConnectionOpenedAsyncCount { get; private set; }
+        public int ConnectionClosingCount { get; private set; }
+        public int ConnectionClosingAsyncCount { get; private set; }
 
         public void ConnectionOpened(DbConnection connection, IDataSession session)
             => ConnectionOpenedCount++;
@@ -158,6 +180,15 @@ public Task ConnectionOpenedAsync(DbConnection connection, IDataSession session,
             ConnectionOpenedAsyncCount++;
             return Task.CompletedTask;
         }
+
+        public void ConnectionClosing(DbConnection connection, IDataSession session)
+            => ConnectionClosingCount++;
+
+        public Task ConnectionClosingAsync(DbConnection connection, IDataSession session, CancellationToken cancellationToken = default)
+        {
+            ConnectionClosingAsyncCount++;
+            return Task.CompletedTask;
+        }
     }
 
     private sealed class TrackingCommandInterceptor : IDataCommandInterceptor
@@ -174,4 +205,25 @@ public Task CommandExecutingAsync(DbCommand command, IDataSession session, Cance
             return Task.CompletedTask;
         }
     }
+
+    private sealed class TrackingLogger<T> : ILogger<T>
+    {
+        public List<string> Messages { get; } = [];
+
+        public IDisposable? BeginScope<TState>(TState state)
+            where TState : notnull
+            => null;
+
+        public bool IsEnabled(LogLevel logLevel) => true;
+
+        public void Log<TState>(
+            LogLevel logLevel,
+            EventId eventId,
+            TState state,
+            Exception? exception,
+            Func<TState, Exception?, string> formatter)
+        {
+            Messages.Add(formatter(state, exception));
+        }
+    }
 }