diff --git a/Directory.Packages.props b/Directory.Packages.props
index f6a9f24815..9ea4ef5995 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -48,6 +48,7 @@
     <PackageVersion Include="Microsoft.DotNet.PlatformAbstractions" Version="3.1.6" />
     <PackageVersion Include="Microsoft.DotNet.RemoteExecutor" Version="11.0.0-beta.25476.3" />
     <PackageVersion Include="Microsoft.DotNet.XUnitExtensions" Version="11.0.0-beta.25476.3" />
+    <PackageVersion Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.3" />
     <PackageVersion Include="Microsoft.Identity.Client" Version="4.78.0" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
     <PackageVersion Include="Microsoft.SqlServer.SqlManagementObjects" Version="172.76.0" />
@@ -109,7 +110,7 @@
     <PackageVersion Include="Microsoft.IdentityModel.JsonWebTokens" Version="8.14.0" />
     <PackageVersion Include="Microsoft.IdentityModel.Protocols.OpenIdConnect" Version="8.14.0" />
     <PackageVersion Include="System.Buffers" Version="4.6.1" />
-    <PackageVersion Include="System.Diagnostics.DiagnosticSource" Version="8.0.1" />
+    <PackageVersion Include="System.Diagnostics.DiagnosticSource" Version="10.0.3" />
     <PackageVersion Include="System.Memory" Version="4.6.3" />
     <PackageVersion Include="System.Runtime.InteropServices.RuntimeInformation" Version="4.3.0" />
     <PackageVersion Include="System.Text.Json" Version="8.0.6" />
diff --git a/src/Microsoft.Data.SqlClient.Extensions/Abstractions/src/Abstractions.csproj b/src/Microsoft.Data.SqlClient.Extensions/Abstractions/src/Abstractions.csproj
index e87452a511..55606de14b 100644
--- a/src/Microsoft.Data.SqlClient.Extensions/Abstractions/src/Abstractions.csproj
+++ b/src/Microsoft.Data.SqlClient.Extensions/Abstractions/src/Abstractions.csproj
@@ -101,15 +101,14 @@
     <None Include="PackageReadme.md" Pack="true" PackagePath="README.md" />
   </ItemGroup>
 
-  <!--
-    Refer to the Logging package via project or package reference
-    depending on our build parameters.
-  -->
-  <ItemGroup Condition="'$(ReferenceType)' == 'Project'">
-    <ProjectReference Include="$(RepoRoot)/src/Microsoft.Data.SqlClient.Extensions/Logging/src/Logging.csproj"/>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" />
   </ItemGroup>
-  <ItemGroup Condition="'$(ReferenceType)' == 'Package'">
-    <PackageReference Include="Microsoft.Data.SqlClient.Extensions.Logging" />
+
+  <ItemGroup>
+    <Compile Include="$(RepoRoot)/src/Microsoft.Data.SqlClient.Extensions/Common/Abstractions/Logging/Logger.cs">
+      <Link>Logging/Logger.cs</Link>
+    </Compile>
   </ItemGroup>
 
   <!--
diff --git a/src/Microsoft.Data.SqlClient.Extensions/Abstractions/src/Logging/CategoryNames.cs b/src/Microsoft.Data.SqlClient.Extensions/Abstractions/src/Logging/CategoryNames.cs
new file mode 100644
index 0000000000..8ac08ee30c
--- /dev/null
+++ b/src/Microsoft.Data.SqlClient.Extensions/Abstractions/src/Logging/CategoryNames.cs
@@ -0,0 +1,16 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.Data.SqlClient.Extensions.Abstractions.Logging;
+
+/// <summary>
+/// The names of logging categories written to by Microsoft.Data.SqlClient.
+/// </summary>
+public static class CategoryNames
+{
+    /// <summary>
+    /// Captures basic application flow trace events.
+    /// </summary>
+    public const string Trace = "Microsoft.Data.SqlClient.Logging.Trace";
+}
diff --git a/src/Microsoft.Data.SqlClient.Extensions/Abstractions/src/Logging/LogMessages.cs b/src/Microsoft.Data.SqlClient.Extensions/Abstractions/src/Logging/LogMessages.cs
new file mode 100644
index 0000000000..5ab589a72f
--- /dev/null
+++ b/src/Microsoft.Data.SqlClient.Extensions/Abstractions/src/Logging/LogMessages.cs
@@ -0,0 +1,46 @@
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.Data.SqlClient.Extensions.Abstractions.Logging;
+
+internal static partial class LogMessages
+{
+    [LoggerMessage(EventId = 1, EventName = nameof(AssemblyNotFound),
+        Level = LogLevel.Warning,
+        Message = $"SqlAuthenticationProvider.Internal | MDS assembly={{assemblyName}} not found; Get/SetProvider() will not function.")]
+    public static partial void AssemblyNotFound(this ILogger logger, string assemblyName);
+
+    [LoggerMessage(EventId = 2, EventName = nameof(AuthManagerClassNotFound),
+        Level = LogLevel.Warning,
+        Message = $"SqlAuthenticationProvider.Internal | MDS auth manager class {{className}} not found; Get/SetProvider() will not function.")]
+    public static partial void AuthManagerClassNotFound(this ILogger logger, string className);
+
+    [LoggerMessage(EventId = 3, EventName = nameof(GetProviderMethodNotFound),
+        Level = LogLevel.Warning,
+        Message = $"SqlAuthenticationProvider.Internal | MDS GetProvider() method not found; Get/SetProvider() will not function.")]
+    public static partial void GetProviderMethodNotFound(this ILogger logger);
+
+    [LoggerMessage(EventId = 4, EventName = nameof(SetProviderMethodNotFound),
+        Level = LogLevel.Warning,
+        Message = $"SqlAuthenticationProvider.Internal | MDS SetProvider() method not found; Get/SetProvider() will not function.")]
+    public static partial void SetProviderMethodNotFound(this ILogger logger);
+
+    [LoggerMessage(EventId = 5, EventName = nameof(AssemblyNotFoundOrUsable),
+        Level = LogLevel.Warning,
+        Message = $"SqlAuthenticationProvider.Internal | MDS assembly={{assemblyName}} not found or not usable; Get/SetProvider() will not function: {{exceptionString}}")]
+    public static partial void AssemblyNotFoundOrUsable(this ILogger logger, string assemblyName, string exceptionString);
+
+    [LoggerMessage(EventId = 6, EventName = nameof(GetProviderInvocationFailed),
+        Level = LogLevel.Warning,
+        Message = $"SqlAuthenticationProvider.Internal | GetProvider() invocation failed: {{exceptionType}}: {{exceptionString}}")]
+    public static partial void GetProviderInvocationFailed(this ILogger logger, string exceptionType, string exceptionString);
+
+    [LoggerMessage(EventId = 7, EventName = nameof(SetProviderInvocationReturnedNull),
+        Level = LogLevel.Warning,
+        Message = $"SqlAuthenticationProvider.Internal | SetProvider() invocation returned null; translating to false.")]
+    public static partial void SetProviderInvocationReturnedNull(this ILogger logger);
+
+    [LoggerMessage(EventId = 8, EventName = nameof(SetProviderInvocationFailed),
+        Level = LogLevel.Warning,
+        Message = $"SqlAuthenticationProvider.Internal | SetProvider() invocation failed: {{exceptionType}}: {{exceptionString}}")]
+    public static partial void SetProviderInvocationFailed(this ILogger logger, string exceptionType, string exceptionString);
+}
diff --git a/src/Microsoft.Data.SqlClient.Extensions/Abstractions/src/Logging/LoggerExtensions.cs b/src/Microsoft.Data.SqlClient.Extensions/Abstractions/src/Logging/LoggerExtensions.cs
new file mode 100644
index 0000000000..0b1e881fd5
--- /dev/null
+++ b/src/Microsoft.Data.SqlClient.Extensions/Abstractions/src/Logging/LoggerExtensions.cs
@@ -0,0 +1,20 @@
+using System.Runtime.CompilerServices;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.Data.SqlClient.Extensions.Abstractions.Logging;
+
+/// <summary>
+/// <see cref="ILogger"/> extension methods for use by Microsoft.Data.SqlClient.
+/// </summary>
+public static class LoggerExtensions
+{
+    /// <summary>
+    /// Begins a logical operation scope, defined by the class name, calling member and a scope identifier.
+    /// </summary>
+    /// <param name="logger"><see cref="ILogger"/> instance to use to begin the scope.</param>
+    /// <param name="className">Class containing the calling member.</param>
+    /// <param name="memberName">Name of the calling member.</param>
+    /// <returns>An <see cref="IDisposable"/> that ends the logical operation scope on dispose.</returns>
+    public static IDisposable? BeginMemberScope(this ILogger logger, string className, [CallerMemberName] string memberName = "") =>
+        logger.BeginScope($"{className}.{memberName} | INFO | SCOPE | Entering Scope {{0}}");
+}
diff --git a/src/Microsoft.Data.SqlClient.Extensions/Abstractions/src/SqlAuthenticationProvider.Internal.cs b/src/Microsoft.Data.SqlClient.Extensions/Abstractions/src/SqlAuthenticationProvider.Internal.cs
index ce904f7df3..4fc27ffcb7 100644
--- a/src/Microsoft.Data.SqlClient.Extensions/Abstractions/src/SqlAuthenticationProvider.Internal.cs
+++ b/src/Microsoft.Data.SqlClient.Extensions/Abstractions/src/SqlAuthenticationProvider.Internal.cs
@@ -2,8 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using Microsoft.Data.SqlClient.Extensions.Abstractions;
+using Microsoft.Data.SqlClient.Extensions.Abstractions.Logging;
 using System.Reflection;
-using System.Runtime.InteropServices;
 
 namespace Microsoft.Data.SqlClient;
 
@@ -48,8 +49,7 @@ static Internal()
 
                 if (assembly is null)
                 {
-                    Log($"MDS assembly={assemblyName} not found; " +
-                        "Get/SetProvider() will not function");
+                    Logger.TraceLogger?.AssemblyNotFound(assemblyName);
                     return;
                 }
 
@@ -62,8 +62,7 @@ static Internal()
 
                 if (manager is null)
                 {
-                    Log($"MDS auth manager manager class={className} not found; " +
-                        "Get/SetProvider() will not function");
+                    Logger.TraceLogger?.AuthManagerClassNotFound(className);
                     return;
                 }
 
@@ -74,8 +73,7 @@ static Internal()
 
                 if (_getProvider is null)
                 {
-                    Log($"MDS GetProvider() method not found; " +
-                        "GetProvider() will not function");
+                    Logger.TraceLogger?.GetProviderMethodNotFound();
                 }
 
                 _setProvider = manager.GetMethod(
@@ -84,8 +82,7 @@ static Internal()
 
                 if (_setProvider is null)
                 {
-                    Log($"MDS SetProvider() method not found; " +
-                        "SetProvider() will not function");
+                    Logger.TraceLogger?.SetProviderMethodNotFound();
                 }
             }
             // All of these exceptions mean we couldn't find the get/set
@@ -96,8 +93,7 @@ or BadImageFormatException
                      or FileLoadException
                      or FileNotFoundException)
             {
-                Log($"MDS assembly={assemblyName} not found or not usable; " +
-                    $"Get/SetProvider() will not function: {ex} ");
+                Logger.TraceLogger?.AssemblyNotFoundOrUsable(assemblyName, ex.ToString());
             }
             // Any other exceptions are fatal.
         }
@@ -132,8 +128,7 @@ or MethodAccessException
                      or NotSupportedException
                      or TargetInvocationException)
             {
-                Log($"GetProvider() invocation failed: " +
-                    $"{ex.GetType().Name}: {ex.Message}");
+                Logger.TraceLogger?.GetProviderInvocationFailed(ex.GetType().Name, ex.ToString());
                 return null;
             }
         }
@@ -169,8 +164,7 @@ internal static bool SetProvider(
 
                 if (!result.HasValue)
                 {
-                    Log($"SetProvider() invocation returned null; " +
-                        "translating to false");
+                    Logger.TraceLogger?.SetProviderInvocationReturnedNull();
                     return false;
                 }
 
@@ -183,15 +177,9 @@ or MethodAccessException
                      or NotSupportedException
                      or TargetInvocationException)
             {
-                Log($"SetProvider() invocation failed: " +
-                    $"{ex.GetType().Name}: {ex.Message}");
+                Logger.TraceLogger?.SetProviderInvocationFailed(ex.GetType().Name, ex.ToString());
                 return false;
             }
         }
-
-        private static void Log(string message)
-        {
-            SqlClientEventSource.Log.TryTraceEvent("SqlAuthenticationProvider.Internal | {0}", message);
-        }
     }
 }
diff --git a/src/Microsoft.Data.SqlClient.Extensions/Azure/src/ActiveDirectoryAuthenticationProvider.cs b/src/Microsoft.Data.SqlClient.Extensions/Azure/src/ActiveDirectoryAuthenticationProvider.cs
index 080bb74c69..c53511e36a 100644
--- a/src/Microsoft.Data.SqlClient.Extensions/Azure/src/ActiveDirectoryAuthenticationProvider.cs
+++ b/src/Microsoft.Data.SqlClient.Extensions/Azure/src/ActiveDirectoryAuthenticationProvider.cs
@@ -8,6 +8,8 @@
 using System.Text;
 using Azure.Core;
 using Azure.Identity;
+using Microsoft.Data.SqlClient.Extensions.Abstractions;
+using Microsoft.Data.SqlClient.Extensions.Azure;
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Identity.Client;
 using Microsoft.Identity.Client.Extensibility;
@@ -101,13 +103,13 @@ public override bool IsSupported(SqlAuthenticationMethod authentication)
     /// <include file='../doc/ActiveDirectoryAuthenticationProvider.xml' path='docs/members[@name="ActiveDirectoryAuthenticationProvider"]/BeforeLoad/*'/>
     public override void BeforeLoad(SqlAuthenticationMethod authentication)
     {
-        SqlClientEventSource.Log.TryTraceEvent("<sc|{0}|{1}|INFO>{2}", _type, "BeforeLoad", $"being loaded into SqlAuthProviders for {authentication}.");
+        Logger.TraceLogger?.BeforeLoadAuthenticationProvider(authentication);
     }
 
     /// <include file='../doc/ActiveDirectoryAuthenticationProvider.xml' path='docs/members[@name="ActiveDirectoryAuthenticationProvider"]/BeforeUnload/*'/>
     public override void BeforeUnload(SqlAuthenticationMethod authentication)
     {
-        SqlClientEventSource.Log.TryTraceEvent("<sc|{0}|{1}|INFO>{2}", _type, "BeforeUnload", $"being unloaded from SqlAuthProviders for {authentication}.");
+        Logger.TraceLogger?.BeforeUnloadAuthenticationProvider(authentication);
     }
 
     #if NETFRAMEWORK
@@ -180,7 +182,7 @@ public override async Task<SqlAuthenticationToken> AcquireTokenAsync(SqlAuthenti
                 // Cache DefaultAzureCredenial based on scope, authority, audience, and clientId
                 TokenCredentialKey tokenCredentialKey = new(typeof(DefaultAzureCredential), authority, scope, audience, clientId);
                 AccessToken accessToken = await GetTokenAsync(tokenCredentialKey, string.Empty, tokenRequestContext, cts.Token).ConfigureAwait(false);
-                SqlClientEventSource.Log.TryTraceEvent("AcquireTokenAsync | Acquired access token for Default auth mode. Expiry Time: {0}", accessToken.ExpiresOn);
+                Logger.TraceLogger?.AcquiredDefaultAuthAccessToken(accessToken.ExpiresOn);
                 return new SqlAuthenticationToken(accessToken.Token, accessToken.ExpiresOn);
             }
 
@@ -189,7 +191,7 @@ public override async Task<SqlAuthenticationToken> AcquireTokenAsync(SqlAuthenti
                 // Cache ManagedIdentityCredential based on scope, authority, and clientId
                 TokenCredentialKey tokenCredentialKey = new(typeof(ManagedIdentityCredential), authority, scope, string.Empty, clientId);
                 AccessToken accessToken = await GetTokenAsync(tokenCredentialKey, string.Empty, tokenRequestContext, cts.Token).ConfigureAwait(false);
-                SqlClientEventSource.Log.TryTraceEvent("AcquireTokenAsync | Acquired access token for Managed Identity auth mode. Expiry Time: {0}", accessToken.ExpiresOn);
+                Logger.TraceLogger?.AcquiredManagedIdentityAuthAccessToken(accessToken.ExpiresOn);
                 return new SqlAuthenticationToken(accessToken.Token, accessToken.ExpiresOn);
             }
 
@@ -199,7 +201,7 @@ public override async Task<SqlAuthenticationToken> AcquireTokenAsync(SqlAuthenti
                 TokenCredentialKey tokenCredentialKey = new(typeof(ClientSecretCredential), authority, scope, audience, clientId);
                 string password = parameters.Password is null ? string.Empty : parameters.Password;
                 AccessToken accessToken = await GetTokenAsync(tokenCredentialKey, password, tokenRequestContext, cts.Token).ConfigureAwait(false);
-                SqlClientEventSource.Log.TryTraceEvent("AcquireTokenAsync | Acquired access token for Active Directory Service Principal auth mode. Expiry Time: {0}", accessToken.ExpiresOn);
+                Logger.TraceLogger?.AcquiredActiveDirectoryServicePrincipalAuthAccessToken(accessToken.ExpiresOn);
                 return new SqlAuthenticationToken(accessToken.Token, accessToken.ExpiresOn);
             }
 
@@ -210,7 +212,7 @@ public override async Task<SqlAuthenticationToken> AcquireTokenAsync(SqlAuthenti
                 // If either tenant id, client id, or the token file path are not specified when fetching the token,
                 // a CredentialUnavailableException will be thrown instead
                 AccessToken accessToken = await GetTokenAsync(tokenCredentialKey, string.Empty, tokenRequestContext, cts.Token).ConfigureAwait(false);
-                SqlClientEventSource.Log.TryTraceEvent("AcquireTokenAsync | Acquired access token for Workload Identity auth mode. Expiry Time: {0}", accessToken.ExpiresOn);
+                Logger.TraceLogger?.AcquiredWorkloadIdentityAuthAccessToken(accessToken.ExpiresOn);
                 return new SqlAuthenticationToken(accessToken.Token, accessToken.ExpiresOn);
             }
 
@@ -265,7 +267,7 @@ public override async Task<SqlAuthenticationToken> AcquireTokenAsync(SqlAuthenti
                         .ExecuteAsync(cancellationToken: cts.Token)
                         .ConfigureAwait(false);
 
-                    SqlClientEventSource.Log.TryTraceEvent("AcquireTokenAsync | Acquired access token for Active Directory Integrated auth mode. Expiry Time: {0}", result?.ExpiresOn);
+                    Logger.TraceLogger?.AcquiredActiveDirectoryIntegratedAuthAccessToken(result?.ExpiresOn);
                 }
             }
             #pragma warning disable CS0618 // Type or member is obsolete
@@ -303,7 +305,7 @@ previousPw is byte[] previousPwBytes &&
                         entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(s_accountPwCacheTtlInHours);
                     }
 
-                    SqlClientEventSource.Log.TryTraceEvent("AcquireTokenAsync | Acquired access token for Active Directory Password auth mode. Expiry Time: {0}", result?.ExpiresOn);
+                    Logger.TraceLogger?.AcquiredActiveDirectoryPasswordAuthAccessToken(result?.ExpiresOn);
                 }
             }
             else if (parameters.AuthenticationMethod == SqlAuthenticationMethod.ActiveDirectoryInteractive ||
@@ -312,7 +314,7 @@ previousPw is byte[] previousPwBytes &&
                 try
                 {
                     result = await TryAcquireTokenSilent(app, parameters, scopes, cts).ConfigureAwait(false);
-                    SqlClientEventSource.Log.TryTraceEvent("AcquireTokenAsync | Acquired access token (silent) for {0} auth mode. Expiry Time: {1}", parameters.AuthenticationMethod, result?.ExpiresOn);
+                    Logger.TraceLogger?.AcquiredSilentAuthAccessToken(parameters.AuthenticationMethod, result?.ExpiresOn);
                 }
                 catch (MsalUiRequiredException)
                 {
@@ -329,12 +331,12 @@ previousPw is byte[] previousPwBytes &&
                 {
                     // If no existing 'account' is found, we request user to sign in interactively.
                     result = await AcquireTokenInteractiveDeviceFlowAsync(app, scopes, parameters.ConnectionId, parameters.UserId, parameters.AuthenticationMethod, cts, _customWebUI, _deviceCodeFlowCallback).ConfigureAwait(false);
-                    SqlClientEventSource.Log.TryTraceEvent("AcquireTokenAsync | Acquired access token (interactive) for {0} auth mode. Expiry Time: {1}", parameters.AuthenticationMethod, result?.ExpiresOn);
+                    Logger.TraceLogger?.AcquiredInteractiveAuthAccessToken(parameters.AuthenticationMethod, result?.ExpiresOn);
                 }
             }
             else
             {
-                SqlClientEventSource.Log.TryTraceEvent("AcquireTokenAsync | {0} authentication mode not supported by ActiveDirectoryAuthenticationProvider class.", parameters.AuthenticationMethod);
+                Logger.TraceLogger?.UnsupportedAuthenticationMode(parameters.AuthenticationMethod);
 
                 throw new Extensions.Azure.AuthenticationException(
                     parameters.AuthenticationMethod,
@@ -484,7 +486,7 @@ or AuthenticationRequiredException
             // If 'account' is available in 'app', we use the same to acquire token silently.
             // Read More on API docs: https://docs.microsoft.com/dotnet/api/microsoft.identity.client.clientapplicationbase.acquiretokensilent
             result = await app.AcquireTokenSilent(scopes, account).ExecuteAsync(cancellationToken: cts.Token).ConfigureAwait(false);
-            SqlClientEventSource.Log.TryTraceEvent("AcquireTokenAsync | Acquired access token (silent) for {0} auth mode. Expiry Time: {1}", parameters.AuthenticationMethod, result?.ExpiresOn);
+            Logger.TraceLogger?.AcquiredSilentAuthAccessToken(parameters.AuthenticationMethod, result?.ExpiresOn);
         }
 
         return result;
@@ -560,7 +562,7 @@ private static async Task<AuthenticationResult> AcquireTokenInteractiveDeviceFlo
         }
         catch (OperationCanceledException ex)
         {
-            SqlClientEventSource.Log.TryTraceEvent("AcquireTokenInteractiveDeviceFlowAsync | Operation timed out while acquiring access token.");
+            Logger.TraceLogger?.AccessTokenAcquisitionTimeout();
 
             throw new Extensions.Azure.AuthenticationException(
                 authenticationMethod,
@@ -589,7 +591,7 @@ private static Task DefaultDeviceFlowCallback(DeviceCodeResult result)
         // * The timeout specified by the server for the lifetime of this code (typically ~15 minutes) has been reached
         // * The developing application calls the Cancel() method on a CancellationToken sent into the method.
         //   If this occurs, an OperationCanceledException will be thrown (see catch below for more details).
-        SqlClientEventSource.Log.TryTraceEvent("AcquireTokenInteractiveDeviceFlowAsync | Callback triggered with Device Code Result: {0}", result.Message);
+        Logger.TraceLogger?.DeviceFlowCallbackTriggered(result.Message);
         Console.WriteLine(result.Message);
         return Task.FromResult(0);
     }
diff --git a/src/Microsoft.Data.SqlClient.Extensions/Azure/src/Azure.csproj b/src/Microsoft.Data.SqlClient.Extensions/Azure/src/Azure.csproj
index 36ca9dd3fc..56972eed1a 100644
--- a/src/Microsoft.Data.SqlClient.Extensions/Azure/src/Azure.csproj
+++ b/src/Microsoft.Data.SqlClient.Extensions/Azure/src/Azure.csproj
@@ -131,6 +131,12 @@
     <PackageReference Include="Microsoft.Identity.Client" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Compile Include="$(RepoRoot)/src/Microsoft.Data.SqlClient.Extensions/Common/Abstractions/Logging/Logger.cs">
+      <Link>Logging/Logger.cs</Link>
+    </Compile>
+  </ItemGroup>
+
   <!--
     Generate ThisAssembly.cs which contains some version information that is
     used at runtime and otherwise would not be available.
diff --git a/src/Microsoft.Data.SqlClient.Extensions/Azure/src/LogMessages.cs b/src/Microsoft.Data.SqlClient.Extensions/Azure/src/LogMessages.cs
new file mode 100644
index 0000000000..a7d89681ad
--- /dev/null
+++ b/src/Microsoft.Data.SqlClient.Extensions/Azure/src/LogMessages.cs
@@ -0,0 +1,75 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.Data.SqlClient.Extensions.Azure;
+
+internal static partial class LogMessages
+{
+    [LoggerMessage(EventId = 11, EventName = nameof(BeforeLoadAuthenticationProvider),
+        Level = LogLevel.Information,
+        Message = $"<sc|{nameof(ActiveDirectoryAuthenticationProvider)}|{nameof(ActiveDirectoryAuthenticationProvider.BeforeLoad)}|INFO> Being loaded into SqlAuthProviders for {{authentication}}")]
+    public static partial void BeforeLoadAuthenticationProvider(this ILogger logger, SqlAuthenticationMethod authentication);
+
+    [LoggerMessage(EventId = 12, EventName = nameof(BeforeUnloadAuthenticationProvider),
+        Level = LogLevel.Information,
+        Message = $"<sc|{nameof(ActiveDirectoryAuthenticationProvider)}|{nameof(ActiveDirectoryAuthenticationProvider.BeforeUnload)}|INFO> Being unloaded from SqlAuthProviders for {{authentication}}")]
+    public static partial void BeforeUnloadAuthenticationProvider(this ILogger logger, SqlAuthenticationMethod authentication);
+
+    [LoggerMessage(EventId = 13, EventName = nameof(AcquiredDefaultAuthAccessToken),
+        Level = LogLevel.Information,
+        Message = $"{nameof(ActiveDirectoryAuthenticationProvider.AcquireTokenAsync)} | Acquired access token for Default auth mode. Expiry Time: {{expiryTime}}")]
+    public static partial void AcquiredDefaultAuthAccessToken(this ILogger logger, DateTimeOffset expiryTime);
+
+    [LoggerMessage(EventId = 14, EventName = nameof(AcquiredManagedIdentityAuthAccessToken),
+        Level = LogLevel.Information,
+        Message = $"{nameof(ActiveDirectoryAuthenticationProvider.AcquireTokenAsync)} | Acquired access token for Managed Identity auth mode. Expiry Time: {{expiryTime}}")]
+    public static partial void AcquiredManagedIdentityAuthAccessToken(this ILogger logger, DateTimeOffset expiryTime);
+
+    [LoggerMessage(EventId = 15, EventName = nameof(AcquiredActiveDirectoryServicePrincipalAuthAccessToken),
+        Level = LogLevel.Information,
+        Message = $"{nameof(ActiveDirectoryAuthenticationProvider.AcquireTokenAsync)} | Acquired access token for Active Directory Service Principal auth mode. Expiry Time: {{expiryTime}}")]
+    public static partial void AcquiredActiveDirectoryServicePrincipalAuthAccessToken(this ILogger logger, DateTimeOffset expiryTime);
+
+    [LoggerMessage(EventId = 16, EventName = nameof(AcquiredWorkloadIdentityAuthAccessToken),
+        Level = LogLevel.Information,
+        Message = $"{nameof(ActiveDirectoryAuthenticationProvider.AcquireTokenAsync)} | Acquired access token for Workload Identity auth mode. Expiry Time: {{expiryTime}}")]
+    public static partial void AcquiredWorkloadIdentityAuthAccessToken(this ILogger logger, DateTimeOffset expiryTime);
+
+    [LoggerMessage(EventId = 17, EventName = nameof(AcquiredActiveDirectoryIntegratedAuthAccessToken),
+        Level = LogLevel.Information,
+        Message = $"{nameof(ActiveDirectoryAuthenticationProvider.AcquireTokenAsync)} | Acquired access token for Active Directory Integrated auth mode. Expiry Time: {{expiryTime}}")]
+    public static partial void AcquiredActiveDirectoryIntegratedAuthAccessToken(this ILogger logger, DateTimeOffset? expiryTime);
+
+    [LoggerMessage(EventId = 18, EventName = nameof(AcquiredActiveDirectoryPasswordAuthAccessToken),
+        Level = LogLevel.Information,
+        Message = $"{nameof(ActiveDirectoryAuthenticationProvider.AcquireTokenAsync)} | Acquired access token for Active Directory Password auth mode. Expiry Time: {{expiryTime}}")]
+    public static partial void AcquiredActiveDirectoryPasswordAuthAccessToken(this ILogger logger, DateTimeOffset? expiryTime);
+
+    [LoggerMessage(EventId = 19, EventName = nameof(AcquiredSilentAuthAccessToken),
+        Level = LogLevel.Information,
+        Message = $"{nameof(ActiveDirectoryAuthenticationProvider.AcquireTokenAsync)} | Acquired access token (silent) for {{authMethod}} auth mode. Expiry Time: {{expiryTime}}")]
+    public static partial void AcquiredSilentAuthAccessToken(this ILogger logger, SqlAuthenticationMethod authMethod, DateTimeOffset? expiryTime);
+
+    [LoggerMessage(EventId = 20, EventName = nameof(AcquiredInteractiveAuthAccessToken),
+        Level = LogLevel.Information,
+        Message = $"{nameof(ActiveDirectoryAuthenticationProvider.AcquireTokenAsync)} | Acquired access token (interactive) for {{authMethod}} auth mode. Expiry Time: {{expiryTime}}")]
+    public static partial void AcquiredInteractiveAuthAccessToken(this ILogger logger, SqlAuthenticationMethod authMethod, DateTimeOffset? expiryTime);
+
+    [LoggerMessage(EventId = 21, EventName = nameof(UnsupportedAuthenticationMode),
+        Level = LogLevel.Information,
+        Message = $"{nameof(ActiveDirectoryAuthenticationProvider.AcquireTokenAsync)} | {{authMethod}} authentication mode not supported by {nameof(ActiveDirectoryAuthenticationProvider)} class.")]
+    public static partial void UnsupportedAuthenticationMode(this ILogger logger, SqlAuthenticationMethod authMethod);
+
+    [LoggerMessage(EventId = 22, EventName = nameof(AccessTokenAcquisitionTimeout),
+        Level = LogLevel.Information,
+        Message = $"AcquireTokenInteractiveDeviceFlowAsync | Operation timed out while acquiring access token.")]
+    public static partial void AccessTokenAcquisitionTimeout(this ILogger logger);
+
+    [LoggerMessage(EventId = 23, EventName = nameof(DeviceFlowCallbackTriggered),
+        Level = LogLevel.Information,
+        Message = $"AcquireTokenInteractiveDeviceFlowAsync | Callback triggered with Device Code Result: {{deviceCodeResult}}.")]
+    public static partial void DeviceFlowCallbackTriggered(this ILogger logger, string deviceCodeResult);
+}
diff --git a/src/Microsoft.Data.SqlClient.Extensions/Common/Abstractions/Logging/Logger.cs b/src/Microsoft.Data.SqlClient.Extensions/Common/Abstractions/Logging/Logger.cs
new file mode 100644
index 0000000000..f6aad9a0b1
--- /dev/null
+++ b/src/Microsoft.Data.SqlClient.Extensions/Common/Abstractions/Logging/Logger.cs
@@ -0,0 +1,98 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.Data.SqlClient.Extensions.Abstractions.Logging;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Diagnostics;
+#if NET
+using System.Diagnostics.CodeAnalysis;
+#endif
+using System.Reflection;
+
+#nullable enable
+
+namespace Microsoft.Data.SqlClient.Extensions.Abstractions;
+
+internal static class Logger
+{
+    private const string AssemblyName = "Microsoft.Data.SqlClient.Extensions.Logging";
+    private const string LoggerProviderTypeName = "Microsoft.Data.SqlClient.Extensions.Logging.SqlClientEventSourceLoggerProvider";
+
+    private static ILoggerProvider? LoggerProvider
+    {
+        #if NET
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026", Justification = "All members of the logger provider are preserved by DynamicDependency.")]
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2075", Justification = "All members of the logger provider are preserved by DynamicDependency.")]
+        [DynamicDependency(DynamicallyAccessedMemberTypes.All, LoggerProviderTypeName, AssemblyName)]
+        #endif
+        get
+        {
+            if (field is not null)
+            {
+                return field;
+            }
+
+            try
+            {
+                // Try to load the MDS assembly.
+                // TODO(https://sqlclientdrivers.visualstudio.com/ADO.Net/_workitems/edit/39845):
+                // Verify the assembly is signed by us?
+                Assembly assembly = Assembly.Load(AssemblyName);
+
+                if (assembly is null)
+                {
+                    Debug.Fail($"MDS assembly={AssemblyName} not found; " +
+                        $"logging will not function.");
+                    return null;
+                }
+
+                Type? loggerProviderType = assembly.GetType(LoggerProviderTypeName);
+
+                if (loggerProviderType is null)
+                {
+                    Debug.Fail($"MDS logger provider class={LoggerProviderTypeName} not found; " +
+                        "logging will not function");
+                    return null;
+                }
+
+                bool isILoggerProvider = typeof(ILoggerProvider).IsAssignableFrom(loggerProviderType);
+                if (!isILoggerProvider)
+                {
+                    Debug.Fail($"MDS logger provider class={LoggerProviderTypeName} does not implement ILoggerProvider; " +
+                        "logging will not function");
+                    return null;
+                }
+
+                ConstructorInfo? ctor = loggerProviderType.GetConstructor(Type.EmptyTypes);
+
+                if (ctor is null)
+                {
+                    Debug.Fail($"MDS logger provider class={LoggerProviderTypeName} does not have a parameterless constructor; " +
+                        "logging will not function");
+                    return null;
+                }
+
+                if (ctor.Invoke(null) is not ILoggerProvider provider)
+                {
+                    Debug.Fail($"MDS logger provider class={LoggerProviderTypeName} could not be instantiated; " +
+                        "logging will not function");
+                    return null;
+                }
+
+                field = provider;
+                return field;
+            }
+            catch
+            {
+                // If any exceptions occur, we can only swallow them silently - without
+                // the logger provider, we have no way to report them.
+                return null;
+            }
+        }
+    }
+
+    public static ILogger? TraceLogger =>
+        field ??= LoggerProvider?.CreateLogger(CategoryNames.Trace);
+}
diff --git a/src/Microsoft.Data.SqlClient.Extensions/Logging/src/EventSourceCategories/TraceLogger.cs b/src/Microsoft.Data.SqlClient.Extensions/Logging/src/EventSourceCategories/TraceLogger.cs
new file mode 100644
index 0000000000..154aa412dd
--- /dev/null
+++ b/src/Microsoft.Data.SqlClient.Extensions/Logging/src/EventSourceCategories/TraceLogger.cs
@@ -0,0 +1,38 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.Data.SqlClient.Extensions.Logging.EventSourceCategories;
+
+internal sealed class TraceLogger : ILogger
+{
+    public static TraceLogger Instance => field ??= new TraceLogger();
+    private TraceLogger() { }
+
+    public IDisposable? BeginScope<TState>(TState state) where TState : notnull
+    {
+        if (!SqlClientEventSource.Log.IsScopeEnabled())
+        {
+            return null;
+        }
+
+        return SqlClientEventAsyncScope.Create("{0}", state);
+    }
+
+    public bool IsEnabled(LogLevel logLevel) =>
+        SqlClientEventSource.Log.IsTraceEnabled() || SqlClientEventSource.Log.IsScopeEnabled();
+
+    public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
+    {
+        if (!SqlClientEventSource.Log.IsTraceEnabled())
+        {
+            return;
+        }
+
+        string message = formatter(state, exception);
+
+        SqlClientEventSource.Log.Trace(message);
+    }
+}
diff --git a/src/Microsoft.Data.SqlClient.Extensions/Logging/src/Logging.csproj b/src/Microsoft.Data.SqlClient.Extensions/Logging/src/Logging.csproj
index e4bc785dd5..0aa32f6241 100644
--- a/src/Microsoft.Data.SqlClient.Extensions/Logging/src/Logging.csproj
+++ b/src/Microsoft.Data.SqlClient.Extensions/Logging/src/Logging.csproj
@@ -101,6 +101,17 @@
     <None Include="PackageReadme.md" Pack="true" PackagePath="README.md" />
   </ItemGroup>
 
+  <!--
+    Refer to the Abstractions package via project or package reference
+    depending on our build parameters.
+  -->
+  <ItemGroup Condition="'$(ReferenceType)' == 'Project'">
+    <ProjectReference Include="$(RepoRoot)/src/Microsoft.Data.SqlClient.Extensions/Abstractions/src/Abstractions.csproj"/>
+  </ItemGroup>
+  <ItemGroup Condition="'$(ReferenceType)' == 'Package'">
+    <PackageReference Include="Microsoft.Data.SqlClient.Extensions.Abstractions" />
+  </ItemGroup>
+
   <!--
     Generate ThisAssembly.cs which contains some version information that is
     used at runtime and otherwise would not be available.
diff --git a/src/Microsoft.Data.SqlClient.Extensions/Logging/src/SqlClientEventSource.cs b/src/Microsoft.Data.SqlClient.Extensions/Logging/src/SqlClientEventSource.cs
index 712e5ee72b..a20ef7babe 100644
--- a/src/Microsoft.Data.SqlClient.Extensions/Logging/src/SqlClientEventSource.cs
+++ b/src/Microsoft.Data.SqlClient.Extensions/Logging/src/SqlClientEventSource.cs
@@ -2,9 +2,13 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.Diagnostics.Tracing;
 using System.Runtime.CompilerServices;
 using System.Text;
+using System.Threading;
+
+#nullable enable
 
 namespace Microsoft.Data.SqlClient
 {
@@ -15,7 +19,7 @@ namespace Microsoft.Data.SqlClient
     /// ETW EventSource for Microsoft.Data.SqlClient tracing and diagnostics.
     /// </summary>
     [EventSource(Name = "Microsoft.Data.SqlClient.EventSource")]
-    public class SqlClientEventSource : EventSource
+    internal sealed class SqlClientEventSource : EventSource
     {
         /// <summary>
         /// Defines the singleton instance for the Resources ETW provider.
@@ -177,7 +181,7 @@ protected override void OnEventCommand(EventCommandEventArgs command)
         /// Each keyword must be a power of 2.
         /// </remarks>
         #region Keywords
-        public class Keywords
+        internal static class Keywords
         {
             /// <summary>
             /// Captures Start/Stop events before and after command execution.
@@ -250,7 +254,7 @@ public class Keywords
         /// <summary>
         /// Tasks supported by SqlClient's EventSource implementation.
         /// </summary>
-        public static class Tasks
+        internal static class Tasks
         {
             /// <summary>
             /// Task that tracks SqlCommand execution.
@@ -1450,7 +1454,7 @@ public void SNIScopeLeave(string message) =>
     /// <summary>
     /// Constants for event type labels used in formatted event messages.
     /// </summary>
-    public static class EventType
+    internal static class EventType
     {
         /// <summary>
         /// Informational event type label.
@@ -1466,7 +1470,7 @@ public static class EventType
     /// <summary>
     /// A disposable scope for SNI event tracing. Automatically leaves the scope when disposed.
     /// </summary>
-    public readonly struct SqlClientSNIEventScope : IDisposable
+    internal readonly struct SqlClientSNIEventScope : IDisposable
     {
         private readonly long _scopeId;
 
@@ -1499,7 +1503,7 @@ public static SqlClientSNIEventScope Create(string className, [CallerMemberName]
     /// <summary>
     /// A disposable scope for general event tracing. Automatically leaves the scope when disposed.
     /// </summary>
-    public readonly ref struct SqlClientEventScope
+    internal readonly ref struct SqlClientEventScope : IDisposable
     {
         private readonly long _scopeId;
 
@@ -1540,4 +1544,44 @@ public void Dispose()
         /// </summary>
         public static SqlClientEventScope Create(long scopeId) => new SqlClientEventScope(scopeId);
     }
+
+    /// <summary>
+    /// A disposable scope for general event tracing. Automatically leaves the scope when disposed.
+    /// Variation of <see cref="SqlClientEventScope"/>, designed for use in async methods where the
+    /// instance may need to be stored across awaits.
+    /// </summary>
+    internal readonly struct SqlClientEventAsyncScope : IDisposable
+    {
+        private readonly long _scopeId;
+
+        public SqlClientEventAsyncScope(long scopeID) => _scopeId = scopeID;
+
+        public void Dispose()
+        {
+            if (_scopeId != 0)
+            {
+                SqlClientEventSource.Log.TryScopeLeaveEvent(_scopeId);
+            }
+        }
+
+        /// <summary>
+        /// Creates a new event scope with one formatted argument.
+        /// </summary>
+        public static SqlClientEventAsyncScope Create<T0>(string message, T0 args0) => new(SqlClientEventSource.Log.TryScopeEnterEvent(message, args0));
+
+        /// <summary>
+        /// Creates a new event scope with two formatted arguments.
+        /// </summary>
+        public static SqlClientEventAsyncScope Create<T0, T1>(string message, T0 args0, T1 args1) => new(SqlClientEventSource.Log.TryScopeEnterEvent(message, args0, args1));
+
+        /// <summary>
+        /// Creates a new event scope for a class with the calling member name.
+        /// </summary>
+        public static SqlClientEventAsyncScope Create(string className, [CallerMemberName] string memberName = "") => new(SqlClientEventSource.Log.TryScopeEnterEvent(className, memberName));
+
+        /// <summary>
+        /// Creates a new event scope with a pre-existing scope identifier.
+        /// </summary>
+        public static SqlClientEventAsyncScope Create(long scopeId) => new(scopeId);
+    }
 }
diff --git a/src/Microsoft.Data.SqlClient.Extensions/Logging/src/SqlClientEventSourceLoggerProvider.cs b/src/Microsoft.Data.SqlClient.Extensions/Logging/src/SqlClientEventSourceLoggerProvider.cs
new file mode 100644
index 0000000000..478716aefd
--- /dev/null
+++ b/src/Microsoft.Data.SqlClient.Extensions/Logging/src/SqlClientEventSourceLoggerProvider.cs
@@ -0,0 +1,39 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.Data.SqlClient.Extensions.Abstractions.Logging;
+using Microsoft.Data.SqlClient.Extensions.Logging.EventSourceCategories;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.Data.SqlClient.Extensions.Logging;
+
+/// <summary>
+/// Represents a type that can create instances of <see cref="TraceLogger"/> which write
+/// events to Microsoft.Data.SqlClient's dedicated event source.
+/// </summary>
+[ProviderAlias(nameof(SqlClientEventSourceLoggerProvider))]
+public sealed class SqlClientEventSourceLoggerProvider : ILoggerProvider
+{
+    /// <summary>
+    /// Creates a new <see cref="ILogger"/> instance.
+    /// </summary>
+    /// <param name="categoryName">The category name for messages produced by the logger.</param>
+    /// <returns>The instance of <see cref="ILogger"/> that was created.</returns>
+    public ILogger CreateLogger(string categoryName)
+    {
+        return categoryName switch
+        {
+            CategoryNames.Trace => TraceLogger.Instance,
+            _ => TraceLogger.Instance,
+        };
+    }
+
+    /// <summary>
+    /// Empty implementation.
+    /// </summary>
+    public void Dispose()
+    {
+        // Implementation deliberately left blank.
+    }
+}
diff --git a/src/Microsoft.Data.SqlClient/add-ons/AzureKeyVaultProvider/AzureSqlKeyCryptographer.cs b/src/Microsoft.Data.SqlClient/add-ons/AzureKeyVaultProvider/AzureSqlKeyCryptographer.cs
index bf41db6dfc..3082d6e6e1 100644
--- a/src/Microsoft.Data.SqlClient/add-ons/AzureKeyVaultProvider/AzureSqlKeyCryptographer.cs
+++ b/src/Microsoft.Data.SqlClient/add-ons/AzureKeyVaultProvider/AzureSqlKeyCryptographer.cs
@@ -1,10 +1,11 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
 using Azure.Core;
 using Azure.Security.KeyVault.Keys;
 using Azure.Security.KeyVault.Keys.Cryptography;
+using Microsoft.Data.SqlClient.Extensions.Abstractions;
 using System;
 using System.Collections.Concurrent;
 using System.Threading;
@@ -97,12 +98,12 @@ internal KeyVaultKey GetKey(string keyIdentifierUri)
         {
             if (_keyDictionary.TryGetValue(keyIdentifierUri, out KeyVaultKey key))
             {
-                SqlClientEventSource.Log.TryTraceEvent("Fetched key name={0} from cache", key.Name);
+                Logger.TraceLogger?.FetchedKeyFromCache(key.Name);
                 return key;
             }
 
             // Not a public exception - not likely to occur.
-            SqlClientEventSource.Log.TryTraceEvent("Key not found; URI={0}", keyIdentifierUri);
+            Logger.TraceLogger?.KeyMissingFromCache(keyIdentifierUri);
             throw ADP.MasterKeyNotFound(keyIdentifierUri);
         }
 
@@ -128,21 +129,21 @@ internal byte[] SignData(byte[] message, string keyIdentifierUri)
         internal bool VerifyData(byte[] message, byte[] signature, string keyIdentifierUri)
         {
             CryptographyClient cryptographyClient = GetCryptographyClient(keyIdentifierUri);
-            SqlClientEventSource.Log.TryTraceEvent("Sending request to verify data");
+            Logger.TraceLogger?.VerifyingData();
             return cryptographyClient.VerifyData(RS256, message, signature).IsValid;
         }
 
         internal byte[] UnwrapKey(KeyWrapAlgorithm keyWrapAlgorithm, byte[] encryptedKey, string keyIdentifierUri)
         {
             CryptographyClient cryptographyClient = GetCryptographyClient(keyIdentifierUri);
-            SqlClientEventSource.Log.TryTraceEvent("Sending request to unwrap key.");
+            Logger.TraceLogger?.UnwrappingKey();
             return cryptographyClient.UnwrapKey(keyWrapAlgorithm, encryptedKey).Key;
         }
 
         internal byte[] WrapKey(KeyWrapAlgorithm keyWrapAlgorithm, byte[] key, string keyIdentifierUri)
         {
             CryptographyClient cryptographyClient = GetCryptographyClient(keyIdentifierUri);
-            SqlClientEventSource.Log.TryTraceEvent("Sending request to wrap key.");
+            Logger.TraceLogger?.WrappingKey();
             return cryptographyClient.WrapKey(keyWrapAlgorithm, key).EncryptedKey;
         }
 
@@ -166,7 +167,7 @@ private CryptographyClient GetCryptographyClient(string keyIdentifierUri)
         /// <param name="keyVersion">The version of the Azure Key Vault key</param>
         private KeyVaultKey FetchKeyFromKeyVault(KeyClient keyClient, string keyName, string keyVersion)
         {
-            SqlClientEventSource.Log.TryTraceEvent("Fetching key name={0}", keyName);
+            Logger.TraceLogger?.FetchingKeyFromKeyVault(keyName);
 
             Azure.Response<KeyVaultKey> keyResponse = keyClient?.GetKey(keyName, keyVersion);
 
@@ -175,10 +176,10 @@ private KeyVaultKey FetchKeyFromKeyVault(KeyClient keyClient, string keyName, st
             // In such cases, we log the error and throw an exception.
             if (keyResponse == null || keyResponse.Value == null || keyResponse.GetRawResponse().IsError)
             {
-                SqlClientEventSource.Log.TryTraceEvent("Get Key failed to fetch Key from Azure Key Vault for key {0}, version {1}", keyName, keyVersion);
+                Logger.TraceLogger?.InvalidKeyVaultResponse(keyName, keyVersion);
                 if (keyResponse?.GetRawResponse() is Azure.Response response)
                 {
-                    SqlClientEventSource.Log.TryTraceEvent("Response status {0} : {1}", response.Status, response.ReasonPhrase);
+                    Logger.TraceLogger?.InvalidKeyVaultResponseCode(response.Status, response.ReasonPhrase);
                 }
                 throw ADP.GetKeyFailed(keyName);
             }
@@ -210,7 +211,7 @@ private static KeyVaultKey ValidateRsaKey(KeyVaultKey key)
         {
             if (key.KeyType != KeyType.Rsa && key.KeyType != KeyType.RsaHsm)
             {
-                SqlClientEventSource.Log.TryTraceEvent("Non-RSA KeyType received: {0}", key.KeyType);
+                Logger.TraceLogger?.NonRsaKeyRetrieved(key.KeyType.ToString());
                 throw ADP.NonRsaKeyFormat(key.KeyType.ToString());
             }
 
@@ -231,8 +232,8 @@ private static void ParseAKVPath(string masterKeyPath, out Uri vaultUri, out str
             masterKeyName = masterKeyPathUri.Segments[2];
             masterKeyVersion = masterKeyPathUri.Segments.Length > 3 ? masterKeyPathUri.Segments[3] : null;
 
-            SqlClientEventSource.Log.TryTraceEvent("Received Key Name: {0}", masterKeyName);
-            SqlClientEventSource.Log.TryTraceEvent("Received Key Version: {0}", masterKeyVersion);
+            Logger.TraceLogger?.ReceivedKeyName(masterKeyName);
+            Logger.TraceLogger?.ReceivedKeyVersion(masterKeyVersion);
         }
     }
 }
diff --git a/src/Microsoft.Data.SqlClient/add-ons/AzureKeyVaultProvider/LocalCache.cs b/src/Microsoft.Data.SqlClient/add-ons/AzureKeyVaultProvider/LocalCache.cs
index cbf7715d10..d0dc3e66af 100644
--- a/src/Microsoft.Data.SqlClient/add-ons/AzureKeyVaultProvider/LocalCache.cs
+++ b/src/Microsoft.Data.SqlClient/add-ons/AzureKeyVaultProvider/LocalCache.cs
@@ -1,8 +1,9 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
 using System;
+using Microsoft.Data.SqlClient.Extensions.Abstractions;
 using Microsoft.Extensions.Caching.Memory;
 using static System.Math;
 
@@ -61,13 +62,13 @@ internal TValue GetOrCreate(TKey key, Func<TValue> createItem)
         {
             if (TimeToLive <= TimeSpan.Zero)
             {
-                SqlClientEventSource.Log.TryTraceEvent("Key caching found disabled, fetching key information.");
+                Logger.TraceLogger?.KeyCachingDisabled();
                 return createItem();
             }
 
             if (!_cache.TryGetValue(key, out TValue cacheEntry))
             {
-                SqlClientEventSource.Log.TryTraceEvent("Cached entry not found, creating new entry.");
+                Logger.TraceLogger?.CachedEntryNotFound();
                 if (_cache.Count == _maxSize)
                 {
                     _cache.Compact(Max(0.10, 1.0 / _maxSize));
@@ -80,11 +81,11 @@ internal TValue GetOrCreate(TKey key, Func<TValue> createItem)
                 };
 
                 _cache.Set(key, cacheEntry, cacheEntryOptions);
-                SqlClientEventSource.Log.TryTraceEvent("Entry added to local cache.");
+                Logger.TraceLogger?.AddedEntryToCache();
             }
             else
             {
-                SqlClientEventSource.Log.TryTraceEvent("Cached entry found.");
+                Logger.TraceLogger?.CachedEntryFound();
             }
 
             return cacheEntry;
diff --git a/src/Microsoft.Data.SqlClient/add-ons/AzureKeyVaultProvider/LogMessages.cs b/src/Microsoft.Data.SqlClient/add-ons/AzureKeyVaultProvider/LogMessages.cs
new file mode 100644
index 0000000000..79a3ccb532
--- /dev/null
+++ b/src/Microsoft.Data.SqlClient/add-ons/AzureKeyVaultProvider/LogMessages.cs
@@ -0,0 +1,125 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider;
+
+internal static partial class LogMessages
+{
+    [LoggerMessage(EventId = 31, EventName = nameof(FetchedKeyFromCache),
+        Level = LogLevel.Information,
+        Message = $"Fetched key name={{keyName}} from cache")]
+    public static partial void FetchedKeyFromCache(this ILogger logger, string keyName);
+
+    [LoggerMessage(EventId = 32, EventName = nameof(KeyMissingFromCache),
+        Level = LogLevel.Information,
+        Message = $"Key not found; URI={{keyIdentifierUri}}")]
+    public static partial void KeyMissingFromCache(this ILogger logger, string keyIdentifierUri);
+
+    [LoggerMessage(EventId = 33, EventName = nameof(VerifyingData),
+        Level = LogLevel.Information,
+        Message = $"Sending request to verify data.")]
+    public static partial void VerifyingData(this ILogger logger);
+
+    [LoggerMessage(EventId = 34, EventName = nameof(UnwrappingKey),
+        Level = LogLevel.Information,
+        Message = $"Sending request to unwrap key.")]
+    public static partial void UnwrappingKey(this ILogger logger);
+
+    [LoggerMessage(EventId = 35, EventName = nameof(WrappingKey),
+        Level = LogLevel.Information,
+        Message = $"Sending request to wrap key.")]
+    public static partial void WrappingKey(this ILogger logger);
+
+    [LoggerMessage(EventId = 36, EventName = nameof(FetchingKeyFromKeyVault),
+        Level = LogLevel.Information,
+        Message = $"Fetching key name={{keyName}}")]
+    public static partial void FetchingKeyFromKeyVault(this ILogger logger, string keyName);
+
+    [LoggerMessage(EventId = 37, EventName = nameof(InvalidKeyVaultResponse),
+        Level = LogLevel.Error,
+        Message = $"Get Key failed to fetch Key from Azure Key Vault for key {{keyName}}, version {{keyVersion}}")]
+    public static partial void InvalidKeyVaultResponse(this ILogger logger, string keyName, string keyVersion);
+
+    [LoggerMessage(EventId = 38, EventName = nameof(InvalidKeyVaultResponseCode),
+        Level = LogLevel.Error,
+        Message = $"Response status {{statusCode}} : {{reasonPhrase}}")]
+    public static partial void InvalidKeyVaultResponseCode(this ILogger logger, int statusCode, string reasonPhrase);
+
+    [LoggerMessage(EventId = 39, EventName = nameof(NonRsaKeyRetrieved),
+        Level = LogLevel.Error,
+        Message = $"Non-RSA KeyType received: {{keyType}}")]
+    public static partial void NonRsaKeyRetrieved(this ILogger logger, string keyType);
+
+    [LoggerMessage(EventId = 40, EventName = nameof(ReceivedKeyName),
+        Level = LogLevel.Information,
+        Message = $"Received Key Name: {{keyName}}")]
+    public static partial void ReceivedKeyName(this ILogger logger, string keyName);
+
+    [LoggerMessage(EventId = 41, EventName = nameof(ReceivedKeyVersion),
+        Level = LogLevel.Information,
+        Message = $"Received Key Version: {{keyVersion}}")]
+    public static partial void ReceivedKeyVersion(this ILogger logger, string keyVersion);
+
+    [LoggerMessage(EventId = 42, EventName = nameof(KeyCachingDisabled),
+        Level = LogLevel.Information,
+        Message = $"Key caching found disabled, fetching key information.")]
+    public static partial void KeyCachingDisabled(this ILogger logger);
+
+    [LoggerMessage(EventId = 43, EventName = nameof(CachedEntryNotFound),
+        Level = LogLevel.Information,
+        Message = $"Cached entry not found, creating new entry.")]
+    public static partial void CachedEntryNotFound(this ILogger logger);
+
+    [LoggerMessage(EventId = 44, EventName = nameof(AddedEntryToCache),
+        Level = LogLevel.Information,
+        Message = $"Entry added to local cache.")]
+    public static partial void AddedEntryToCache(this ILogger logger);
+
+    [LoggerMessage(EventId = 45, EventName = nameof(CachedEntryFound),
+        Level = LogLevel.Information,
+        Message = $"Cached entry found.")]
+    public static partial void CachedEntryFound(this ILogger logger);
+
+    [LoggerMessage(EventId = 46, EventName = nameof(InvalidCipherTextLength),
+        Level = LogLevel.Error,
+        Message = $"Cipher Text length: {{cipherTextLength}}; Key size (bytes): {{keySizeInBytes}}")]
+    public static partial void InvalidCipherTextLength(this ILogger logger, int cipherTextLength, int keySizeInBytes);
+
+    [LoggerMessage(EventId = 47, EventName = nameof(InvalidSignatureLength),
+        Level = LogLevel.Error,
+        Message = $"Signature length: {{signatureTextLength}}; Key size (bytes): {{keySizeInBytes}}")]
+    public static partial void InvalidSignatureLength(this ILogger logger, int signatureTextLength, int keySizeInBytes);
+
+    [LoggerMessage(EventId = 48, EventName = nameof(CouldNotVerifySignature),
+        Level = LogLevel.Error,
+        Message = $"Signature could not be verified.")]
+    public static partial void CouldNotVerifySignature(this ILogger logger);
+
+    [LoggerMessage(EventId = 49, EventName = nameof(NullOrEmptyUri),
+        Level = LogLevel.Error,
+        Message = $"Azure Key Vault URI found null or empty.")]
+    public static partial void NullOrEmptyUri(this ILogger logger);
+
+    [LoggerMessage(EventId = 50, EventName = nameof(MasterKeyPathNotValidUrl),
+        Level = LogLevel.Error,
+        Message = $"URI could not be created with provided master key path: {{masterKeyPath}}")]
+    public static partial void MasterKeyPathNotValidUrl(this ILogger logger, string masterKeyPath);
+
+    [LoggerMessage(EventId = 51, EventName = nameof(MasterKeyPathValid),
+        Level = LogLevel.Information,
+        Message = $"Azure Key Vault URI validated successfully.")]
+    public static partial void MasterKeyPathValid(this ILogger logger);
+
+    [LoggerMessage(EventId = 52, EventName = nameof(MasterKeyPathNotTrustedUrl),
+        Level = LogLevel.Error,
+        Message = $"Master Key Path could not be validated as it does not end with trusted endpoints: {{masterKeyPath}}")]
+    public static partial void MasterKeyPathNotTrustedUrl(this ILogger logger, string masterKeyPath);
+
+    [LoggerMessage(EventId = 53, EventName = nameof(VerifiedSignature),
+        Level = LogLevel.Information,
+        Message = $"Signature verified successfully.")]
+    public static partial void VerifiedSignature(this ILogger logger);
+}
diff --git a/src/Microsoft.Data.SqlClient/add-ons/AzureKeyVaultProvider/Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider.csproj b/src/Microsoft.Data.SqlClient/add-ons/AzureKeyVaultProvider/Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider.csproj
index 560d12474b..1a0258dd5d 100644
--- a/src/Microsoft.Data.SqlClient/add-ons/AzureKeyVaultProvider/Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider.csproj
+++ b/src/Microsoft.Data.SqlClient/add-ons/AzureKeyVaultProvider/Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider.csproj
@@ -43,4 +43,10 @@
     <PackageReference Include="Azure.Security.KeyVault.Keys" />
     <PackageReference Include="Microsoft.Extensions.Caching.Memory" />
   </ItemGroup>
+
+  <ItemGroup>
+    <Compile Include="$(RepoRoot)/src/Microsoft.Data.SqlClient.Extensions/Common/Abstractions/Logging/Logger.cs">
+      <Link>Logging/Logger.cs</Link>
+    </Compile>
+  </ItemGroup>
 </Project>
diff --git a/src/Microsoft.Data.SqlClient/add-ons/AzureKeyVaultProvider/SqlColumnEncryptionAzureKeyVaultProvider.cs b/src/Microsoft.Data.SqlClient/add-ons/AzureKeyVaultProvider/SqlColumnEncryptionAzureKeyVaultProvider.cs
index 08639abe2c..d0c0ccf570 100644
--- a/src/Microsoft.Data.SqlClient/add-ons/AzureKeyVaultProvider/SqlColumnEncryptionAzureKeyVaultProvider.cs
+++ b/src/Microsoft.Data.SqlClient/add-ons/AzureKeyVaultProvider/SqlColumnEncryptionAzureKeyVaultProvider.cs
@@ -7,6 +7,8 @@
 using System.Threading;
 using Azure.Core;
 using Azure.Security.KeyVault.Keys.Cryptography;
+using Microsoft.Data.SqlClient.Extensions.Abstractions;
+using Microsoft.Data.SqlClient.Extensions.Abstractions.Logging;
 using static Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider.Validator;
 
 namespace Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider
@@ -119,7 +121,7 @@ public SqlColumnEncryptionAzureKeyVaultProvider(TokenCredential tokenCredential,
         /// <param name="trustedEndpoints">TrustedEndpoints are used to validate the master key path</param>
         public SqlColumnEncryptionAzureKeyVaultProvider(TokenCredential tokenCredential, string[] trustedEndpoints)
         {
-            using var _ = SqlClientEventScope.Create(nameof(SqlColumnEncryptionAzureKeyVaultProvider));
+            using var _ = Logger.TraceLogger?.BeginMemberScope(nameof(SqlColumnEncryptionAzureKeyVaultProvider));
             ValidateNotNull(tokenCredential, nameof(tokenCredential));
             ValidateNotNull(trustedEndpoints, nameof(trustedEndpoints));
             ValidateNotEmpty(trustedEndpoints, nameof(trustedEndpoints));
@@ -140,7 +142,7 @@ public SqlColumnEncryptionAzureKeyVaultProvider(TokenCredential tokenCredential,
         /// <returns>Encrypted column encryption key</returns>
         public override byte[] SignColumnMasterKeyMetadata(string masterKeyPath, bool allowEnclaveComputations)
         {
-            using var _ = SqlClientEventScope.Create(nameof(SqlColumnEncryptionAzureKeyVaultProvider));
+            using var _ = Logger.TraceLogger?.BeginMemberScope(nameof(SqlColumnEncryptionAzureKeyVaultProvider));
             ValidateNonEmptyAKVPath(masterKeyPath, isSystemOp: false);
 
             // Also validates key is of RSA type.
@@ -158,7 +160,7 @@ public override byte[] SignColumnMasterKeyMetadata(string masterKeyPath, bool al
         /// <returns>Boolean indicating whether the master key metadata can be verified based on the provided signature</returns>
         public override bool VerifyColumnMasterKeyMetadata(string masterKeyPath, bool allowEnclaveComputations, byte[] signature)
         {
-            using var _ = SqlClientEventScope.Create(nameof(SqlColumnEncryptionAzureKeyVaultProvider));
+            using var _ = Logger.TraceLogger?.BeginMemberScope(nameof(SqlColumnEncryptionAzureKeyVaultProvider));
             ValidateNonEmptyAKVPath(masterKeyPath, isSystemOp: true);
 
             var key = Tuple.Create(masterKeyPath, allowEnclaveComputations, ToHexString(signature));
@@ -183,7 +185,7 @@ bool VerifyColumnMasterKeyMetadata()
         /// <returns>Plain text column encryption key</returns>
         public override byte[] DecryptColumnEncryptionKey(string masterKeyPath, string encryptionAlgorithm, byte[] encryptedColumnEncryptionKey)
         {
-            using var _ = SqlClientEventScope.Create(nameof(SqlColumnEncryptionAzureKeyVaultProvider));
+            using var _ = Logger.TraceLogger?.BeginMemberScope(nameof(SqlColumnEncryptionAzureKeyVaultProvider));
             // Validate the input parameters
             ValidateNonEmptyAKVPath(masterKeyPath, isSystemOp: true);
             ValidateEncryptionAlgorithm(encryptionAlgorithm, isSystemOp: true);
@@ -216,8 +218,7 @@ byte[] DecryptEncryptionKey()
                 // validate the ciphertext length
                 if (cipherTextLength != keySizeInBytes)
                 {
-                    SqlClientEventSource.Log.TryTraceEvent("Cipher Text length: {0}", cipherTextLength);
-                    SqlClientEventSource.Log.TryTraceEvent("keySizeInBytes: {0}", keySizeInBytes);
+                    Logger.TraceLogger?.InvalidCipherTextLength(cipherTextLength, keySizeInBytes);
                     throw ADP.InvalidCipherTextLength(cipherTextLength, keySizeInBytes, masterKeyPath);
                 }
 
@@ -225,8 +226,7 @@ byte[] DecryptEncryptionKey()
                 int signatureLength = encryptedColumnEncryptionKey.Length - currentIndex - cipherTextLength;
                 if (signatureLength != keySizeInBytes)
                 {
-                    SqlClientEventSource.Log.TryTraceEvent("Signature length: {0}", signatureLength);
-                    SqlClientEventSource.Log.TryTraceEvent("keySizeInBytes: {0}", keySizeInBytes);
+                    Logger.TraceLogger?.InvalidSignatureLength(signatureLength, keySizeInBytes);
                     throw ADP.InvalidSignatureLengthTemplate(signatureLength, keySizeInBytes, masterKeyPath);
                 }
 
@@ -251,7 +251,7 @@ byte[] DecryptEncryptionKey()
 
                 if (!KeyCryptographer.VerifyData(message, signature, masterKeyPath))
                 {
-                    SqlClientEventSource.Log.TryTraceEvent("Signature could not be verified.");
+                    Logger.TraceLogger?.CouldNotVerifySignature();
                     throw ADP.InvalidSignatureTemplate(masterKeyPath);
                 }
                 return KeyCryptographer.UnwrapKey(s_keyWrapAlgorithm, cipherText, masterKeyPath);
@@ -268,7 +268,7 @@ byte[] DecryptEncryptionKey()
         /// <returns>Encrypted column encryption key</returns>
         public override byte[] EncryptColumnEncryptionKey(string masterKeyPath, string encryptionAlgorithm, byte[] columnEncryptionKey)
         {
-            using var _ = SqlClientEventScope.Create(nameof(SqlColumnEncryptionAzureKeyVaultProvider));
+            using var _ = Logger.TraceLogger?.BeginMemberScope(nameof(SqlColumnEncryptionAzureKeyVaultProvider));
             // Validate the input parameters
             ValidateNonEmptyAKVPath(masterKeyPath, isSystemOp: true);
             ValidateEncryptionAlgorithm(encryptionAlgorithm, isSystemOp: true);
@@ -293,8 +293,7 @@ public override byte[] EncryptColumnEncryptionKey(string masterKeyPath, string e
 
             if (cipherText.Length != keySizeInBytes)
             {
-                SqlClientEventSource.Log.TryTraceEvent("Cipher Text length: {0}", cipherText.Length);
-                SqlClientEventSource.Log.TryTraceEvent("keySizeInBytes: {0}", keySizeInBytes);
+                Logger.TraceLogger?.InvalidCipherTextLength(cipherText.Length, keySizeInBytes);
                 throw ADP.CipherTextLengthMismatch();
             }
 
@@ -348,14 +347,14 @@ internal void ValidateNonEmptyAKVPath(string masterKeyPath, bool isSystemOp)
             // throw appropriate error if masterKeyPath is null or empty
             if (string.IsNullOrWhiteSpace(masterKeyPath))
             {
-                SqlClientEventSource.Log.TryTraceEvent("Azure Key Vault URI found null or empty.");
+                Logger.TraceLogger?.NullOrEmptyUri();
                 throw ADP.InvalidAKVPath(masterKeyPath, isSystemOp);
             }
 
             if (!Uri.TryCreate(masterKeyPath, UriKind.Absolute, out Uri parsedUri) || parsedUri.Segments.Length < 3)
             {
                 // Return an error indicating that the AKV url is invalid.
-                SqlClientEventSource.Log.TryTraceEvent("URI could not be created with provided master key path: {0}", masterKeyPath);
+                Logger.TraceLogger?.MasterKeyPathNotValidUrl(masterKeyPath);
                 throw ADP.InvalidAKVUrl(masterKeyPath);
             }
 
@@ -365,13 +364,13 @@ internal void ValidateNonEmptyAKVPath(string masterKeyPath, bool isSystemOp)
             {
                 if (parsedUri.Host.EndsWith(trustedEndPoint, StringComparison.OrdinalIgnoreCase))
                 {
-                    SqlClientEventSource.Log.TryTraceEvent("Azure Key Vault URI validated successfully.");
+                    Logger.TraceLogger?.MasterKeyPathValid();
                     return;
                 }
             }
 
             // Return an error indicating that the AKV url is invalid.
-            SqlClientEventSource.Log.TryTraceEvent("Master Key Path could not be validated as it does not end with trusted endpoints: {0}", masterKeyPath);
+            Logger.TraceLogger?.MasterKeyPathNotTrustedUrl(masterKeyPath);
             throw ADP.InvalidAKVUrlTrustedEndpoints(masterKeyPath, string.Join(", ", TrustedEndPoints));
         }
 
@@ -379,10 +378,10 @@ private void ValidateSignature(string masterKeyPath, byte[] message, byte[] sign
         {
             if (!KeyCryptographer.VerifyData(message, signature, masterKeyPath))
             {
-                SqlClientEventSource.Log.TryTraceEvent("Signature could not be verified.");
+                Logger.TraceLogger?.CouldNotVerifySignature();
                 throw ADP.InvalidSignature();
             }
-            SqlClientEventSource.Log.TryTraceEvent("Signature verified successfully.");
+            Logger.TraceLogger?.VerifiedSignature();
         }
 
         private byte[] CompileMasterKeyMetadata(string masterKeyPath, bool allowEnclaveComputations)
diff --git a/src/Microsoft.Data.SqlClient/netcore/src/Microsoft.Data.SqlClient.csproj b/src/Microsoft.Data.SqlClient/netcore/src/Microsoft.Data.SqlClient.csproj
index 3ad83ed492..469e9d2a27 100644
--- a/src/Microsoft.Data.SqlClient/netcore/src/Microsoft.Data.SqlClient.csproj
+++ b/src/Microsoft.Data.SqlClient/netcore/src/Microsoft.Data.SqlClient.csproj
@@ -699,8 +699,8 @@
     <Compile Include="$(CommonSourceRoot)Microsoft\Data\SqlClient\SqlClientEncryptionType.cs">
       <Link>Microsoft\Data\SqlClient\SqlClientEncryptionType.cs</Link>
     </Compile>
-    <Compile Include="$(CommonSourceRoot)Microsoft\Data\SqlClient\SqlClientEventSource.cs">
-      <Link>Microsoft\Data\SqlClient\SqlClientEventSource.cs</Link>
+    <Compile Include="$(CommonSourceRoot)Microsoft\Data\SqlClient\SqlClientDiagnostics.cs">
+      <Link>Microsoft\Data\SqlClient\SqlClientDiagnostics.cs</Link>
     </Compile>
     <Compile Include="$(CommonSourceRoot)Microsoft\Data\SqlClient\SqlClientFactory.cs">
       <Link>Microsoft\Data\SqlClient\SqlClientFactory.cs</Link>
@@ -1023,6 +1023,9 @@
     <Compile Include="$(CommonSourceRoot)TypeForwards.netcore.cs">
       <Link>TypeForwards.netcore.cs</Link>
     </Compile>
+    <Compile Include="$(RepoRoot)\src\Microsoft.Data.SqlClient.Extensions\Logging\src\SqlClientEventSource.cs">
+      <Link>Microsoft\Data\SqlClient\SqlClientEventSource.cs</Link>
+    </Compile>
   </ItemGroup>
 
   <!-- Resource Files ================================================== -->
diff --git a/src/Microsoft.Data.SqlClient/netfx/src/Microsoft.Data.SqlClient.csproj b/src/Microsoft.Data.SqlClient/netfx/src/Microsoft.Data.SqlClient.csproj
index cdd54bd244..5efdc3c574 100644
--- a/src/Microsoft.Data.SqlClient/netfx/src/Microsoft.Data.SqlClient.csproj
+++ b/src/Microsoft.Data.SqlClient/netfx/src/Microsoft.Data.SqlClient.csproj
@@ -682,8 +682,8 @@
     <Compile Include="$(CommonSourceRoot)Microsoft\Data\SqlClient\SqlClientEncryptionType.cs">
       <Link>Microsoft\Data\SqlClient\SqlClientEncryptionType.cs</Link>
     </Compile>
-    <Compile Include="$(CommonSourceRoot)Microsoft\Data\SqlClient\SqlClientEventSource.cs">
-      <Link>Microsoft\Data\SqlClient\SqlClientEventSource.cs</Link>
+    <Compile Include="$(CommonSourceRoot)Microsoft\Data\SqlClient\SqlClientDiagnostics.cs">
+      <Link>Microsoft\Data\SqlClient\SqlClientDiagnostics.cs</Link>
     </Compile>
     <Compile Include="$(CommonSourceRoot)Microsoft\Data\SqlClient\SqlClientFactory.cs">
       <Link>Microsoft\Data\SqlClient\SqlClientFactory.cs</Link>
@@ -1006,6 +1006,9 @@
     <Compile Include="$(CommonSourceRoot)System\Runtime\CompilerServices\IsExternalInit.netfx.cs">
       <Link>System\Runtime\CompilerServices\IsExternalInit.netfx.cs</Link>
     </Compile>
+    <Compile Include="$(RepoRoot)\src\Microsoft.Data.SqlClient.Extensions\Logging\src\SqlClientEventSource.cs">
+      <Link>Microsoft\Data\SqlClient\SqlClientEventSource.cs</Link>
+    </Compile>
   </ItemGroup>
 
   <!-- Resource Files ================================================== -->
diff --git a/src/Microsoft.Data.SqlClient/src/Microsoft.Data.SqlClient.csproj b/src/Microsoft.Data.SqlClient/src/Microsoft.Data.SqlClient.csproj
index 2e9045ee83..5e4302c894 100644
--- a/src/Microsoft.Data.SqlClient/src/Microsoft.Data.SqlClient.csproj
+++ b/src/Microsoft.Data.SqlClient/src/Microsoft.Data.SqlClient.csproj
@@ -66,6 +66,12 @@
     <OutputPath>$(ArtifactPath)$(AssemblyName)/$(Configuration)/$(NormalizedTargetOs)/</OutputPath>
   </PropertyGroup>
 
+  <ItemGroup>
+    <Compile Include="$(RepoRoot)\src\Microsoft.Data.SqlClient.Extensions\Logging\src\SqlClientEventSource.cs">
+      <Link>Microsoft\Data\SqlClient\SqlClientEventSource.cs</Link>
+    </Compile>
+  </ItemGroup>
+
   <!-- Embedded resources ============================================== -->
   <ItemGroup>
     <!-- Linker directives to replace UseManagedNetworking with a constant if consumer specifies  -->
diff --git a/src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlClientEventSource.cs b/src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlClientDiagnostics.cs
similarity index 100%
rename from src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlClientEventSource.cs
rename to src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlClientDiagnostics.cs