Make UseLogging a nop when NullLoggerFactory is used

src/Libraries/Microsoft.Extensions.AI/ChatCompletion/LoggingChatClientBuilderExtensions.cs

@@ -4,6 +4,7 @@
 using System;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
 using Microsoft.Shared.Diagnostics;
 
 namespace Microsoft.Extensions.AI;
@@ -29,6 +30,14 @@ public static ChatClientBuilder UseLogging(
         return builder.Use((innerClient, services) =>
         {
             loggerFactory ??= services.GetRequiredService<ILoggerFactory>();
+
+            // If the factory we resolve is for the null logger, the LoggingChatClient will end up
+            // being an expensive nop, so skip adding it and just return the inner client.
+            if (loggerFactory == NullLoggerFactory.Instance)
+            {
+                return innerClient;
+            }
+
             var chatClient = new LoggingChatClient(innerClient, loggerFactory.CreateLogger(typeof(LoggingChatClient)));
             configure?.Invoke(chatClient);
             return chatClient;

src/Libraries/Microsoft.Extensions.AI/Embeddings/LoggingEmbeddingGeneratorBuilderExtensions.cs

@@ -4,6 +4,7 @@
 using System;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
 using Microsoft.Shared.Diagnostics;
 
 namespace Microsoft.Extensions.AI;
@@ -32,6 +33,14 @@ public static EmbeddingGeneratorBuilder<TInput, TEmbedding> UseLogging<TInput, T
         return builder.Use((innerGenerator, services) =>
         {
             loggerFactory ??= services.GetRequiredService<ILoggerFactory>();
+
+            // If the factory we resolve is for the null logger, the LoggingEmbeddingGenerator will end up
+            // being an expensive nop, so skip adding it and just return the inner generator.
+            if (loggerFactory == NullLoggerFactory.Instance)
+            {
+                return innerGenerator;
+            }
+
             var generator = new LoggingEmbeddingGenerator<TInput, TEmbedding>(innerGenerator, loggerFactory.CreateLogger(typeof(LoggingEmbeddingGenerator<TInput, TEmbedding>)));
             configure?.Invoke(generator);
             return generator;

test/Libraries/Microsoft.Extensions.AI.Abstractions.Tests/TestChatClient.cs

@@ -10,6 +10,11 @@ namespace Microsoft.Extensions.AI;
 
 public sealed class TestChatClient : IChatClient
 {
+    public TestChatClient()
+    {
+        GetServiceCallback = DefaultGetServiceCallback;
+    }
+
     public IServiceProvider? Services { get; set; }
 
     public ChatClientMetadata Metadata { get; set; } = new();
@@ -18,7 +23,10 @@ public sealed class TestChatClient : IChatClient
 
     public Func<IList<ChatMessage>, ChatOptions?, CancellationToken, IAsyncEnumerable<StreamingChatCompletionUpdate>>? CompleteStreamingAsyncCallback { get; set; }
 
-    public Func<Type, object?, object?> GetServiceCallback { get; set; } = (_, _) => null;
+    public Func<Type, object?, object?> GetServiceCallback { get; set; }
+
+    private object? DefaultGetServiceCallback(Type serviceType, object? serviceKey) =>
+        serviceType is not null && serviceKey is null && serviceType.IsInstanceOfType(this) ? this : null;
 
     public Task<ChatCompletion> CompleteAsync(IList<ChatMessage> chatMessages, ChatOptions? options = null, CancellationToken cancellationToken = default)
         => CompleteAsyncCallback!.Invoke(chatMessages, options, cancellationToken);

test/Libraries/Microsoft.Extensions.AI.Abstractions.Tests/TestEmbeddingGenerator.cs

@@ -10,11 +10,19 @@ namespace Microsoft.Extensions.AI;
 
 public sealed class TestEmbeddingGenerator : IEmbeddingGenerator<string, Embedding<float>>
 {
+    public TestEmbeddingGenerator()
+    {
+        GetServiceCallback = DefaultGetServiceCallback;
+    }
+
     public EmbeddingGeneratorMetadata Metadata { get; } = new();
 
     public Func<IEnumerable<string>, EmbeddingGenerationOptions?, CancellationToken, Task<GeneratedEmbeddings<Embedding<float>>>>? GenerateAsyncCallback { get; set; }
 
-    public Func<Type, object?, object?> GetServiceCallback { get; set; } = (_, _) => null;
+    public Func<Type, object?, object?> GetServiceCallback { get; set; }
+
+    private object? DefaultGetServiceCallback(Type serviceType, object? serviceKey) =>
+        serviceType is not null && serviceKey is null && serviceType.IsInstanceOfType(this) ? this : null;
 
     public Task<GeneratedEmbeddings<Embedding<float>>> GenerateAsync(IEnumerable<string> values, EmbeddingGenerationOptions? options = null, CancellationToken cancellationToken = default)
         => GenerateAsyncCallback!.Invoke(values, options, cancellationToken);

test/Libraries/Microsoft.Extensions.AI.Tests/ChatCompletion/LoggingChatClientTests.cs

@@ -21,6 +21,25 @@ public void LoggingChatClient_InvalidArgs_Throws()
         Assert.Throws<ArgumentNullException>("logger", () => new LoggingChatClient(new TestChatClient(), null!));
     }
 
+    [Fact]
+    public void UseLogging_AvoidsInjectingNopClient()
+    {
+        using var innerClient = new TestChatClient();
+
+        Assert.Null(innerClient.AsBuilder().UseLogging(NullLoggerFactory.Instance).Build().GetService(typeof(LoggingChatClient)));
+        Assert.Same(innerClient, innerClient.AsBuilder().UseLogging(NullLoggerFactory.Instance).Build().GetService(typeof(IChatClient)));
+
+        using var factory = LoggerFactory.Create(b => b.AddFakeLogging());
+        Assert.NotNull(innerClient.AsBuilder().UseLogging(factory).Build().GetService(typeof(LoggingChatClient)));
+
+        ServiceCollection c = new();
+        c.AddFakeLogging();
+        var services = c.BuildServiceProvider();
+        Assert.NotNull(innerClient.AsBuilder().UseLogging().Build(services).GetService(typeof(LoggingChatClient)));
+        Assert.NotNull(innerClient.AsBuilder().UseLogging(null).Build(services).GetService(typeof(LoggingChatClient)));
+        Assert.Null(innerClient.AsBuilder().UseLogging(NullLoggerFactory.Instance).Build(services).GetService(typeof(LoggingChatClient)));
+    }
+
     [Theory]
     [InlineData(LogLevel.Trace)]
     [InlineData(LogLevel.Debug)]

test/Libraries/Microsoft.Extensions.AI.Tests/Embeddings/LoggingEmbeddingGeneratorTests.cs

@@ -20,6 +20,25 @@ public void LoggingEmbeddingGenerator_InvalidArgs_Throws()
         Assert.Throws<ArgumentNullException>("logger", () => new LoggingEmbeddingGenerator<string, Embedding<float>>(new TestEmbeddingGenerator(), null!));
     }
 
+    [Fact]
+    public void UseLogging_AvoidsInjectingNopClient()
+    {
+        using var innerGenerator = new TestEmbeddingGenerator();
+
+        Assert.Null(innerGenerator.AsBuilder().UseLogging(NullLoggerFactory.Instance).Build().GetService(typeof(LoggingEmbeddingGenerator<string, Embedding<float>>)));
+        Assert.Same(innerGenerator, innerGenerator.AsBuilder().UseLogging(NullLoggerFactory.Instance).Build().GetService(typeof(IEmbeddingGenerator<string, Embedding<float>>)));
+
+        using var factory = LoggerFactory.Create(b => b.AddFakeLogging());
+        Assert.NotNull(innerGenerator.AsBuilder().UseLogging(factory).Build().GetService(typeof(LoggingEmbeddingGenerator<string, Embedding<float>>)));
+
+        ServiceCollection c = new();
+        c.AddFakeLogging();
+        var services = c.BuildServiceProvider();
+        Assert.NotNull(innerGenerator.AsBuilder().UseLogging().Build(services).GetService(typeof(LoggingEmbeddingGenerator<string, Embedding<float>>)));
+        Assert.NotNull(innerGenerator.AsBuilder().UseLogging(null).Build(services).GetService(typeof(LoggingEmbeddingGenerator<string, Embedding<float>>)));
+        Assert.Null(innerGenerator.AsBuilder().UseLogging(NullLoggerFactory.Instance).Build(services).GetService(typeof(LoggingEmbeddingGenerator<string, Embedding<float>>)));
+    }
+
     [Theory]
     [InlineData(LogLevel.Trace)]
     [InlineData(LogLevel.Debug)]