feat: Extend logging configuration. Format logs by default. (#242)

## Summary

Allow further logging configuration.

## How did you test this change?

Unit and manual tests.

Author: kinyoklion

sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/Asp/Core/ObservabilityExtensions.cs

@@ -67,7 +67,12 @@ internal static void AddLaunchDarklyObservabilityWithConfig(this IServiceCollect
                         options.WithCommonLaunchDarklyLoggingExport(config);
                     });
                 config.ExtendedLoggerConfiguration?.Invoke(logging);
-            }).WithMetrics(metrics =>
+            }, options =>
+            {
+                options.IncludeFormattedMessage = true;
+                config.ExtendedLoggerOptionsConfiguration?.Invoke(options);
+            })
+            .WithMetrics(metrics =>
             {
                 metrics
                     .WithCommonLaunchDarklyConfig(config, resourceBuilder)

sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/Asp/Core/ObservabilityPlugin.cs

@@ -101,6 +101,13 @@ internal ObservabilityPluginBuilder(IServiceCollection services) : base()
                     "Service collection cannot be null when creating an ObservabilityPlugin builder.");
             }
 
+            public ObservabilityPluginBuilder WithExtendedLoggerConfiguration(Action<LoggerProviderBuilder> extendedLoggerConfiguration, Action<OpenTelemetryLoggerOptions> configureLoggerOptions)
+            {
+                WithExtendedLoggerConfiguration(extendedLoggerConfiguration);
+                ConfigureLoggerOptions = configureLoggerOptions;
+                return this;
+            }
+
             /// <summary>
             /// Build an <see cref="ObservabilityPlugin"/> instance with the configured settings.
             /// </summary>

sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/Asp/Legacy/OpenTelemetryConfig.cs

@@ -34,7 +34,6 @@ public static void AddLaunchDarklyLogging(this ILoggingBuilder loggingBuilder, O
                 options.SetResourceBuilder(CommonOtelOptions.GetResourceBuilder(config))
                     .AddProcessor(new SamplingLogProcessor(CommonOtelOptions.GetSampler(config)))
                     .AddOtlpExporter(exportOptions => { exportOptions.WithCommonLaunchDarklyLoggingExport(config); });
-
                 config.ExtendedLoggerConfiguration?.Invoke(options);
             });
         }

sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/BaseBuilder.cs

@@ -31,6 +31,9 @@ public class BaseBuilder<TBuilder> where TBuilder : BaseBuilder<TBuilder>
         private Action<TracerProviderBuilder> _extendedTracerConfiguration;
         private Action<LoggerBuilderType> _extendedLoggerConfiguration;
         private Action<MeterProviderBuilder> _extendedMeterConfiguration;
+#if !NETFRAMEWORK
+        protected Action<OpenTelemetryLoggerOptions> ConfigureLoggerOptions;
+#endif
 
         protected BaseBuilder()
         {
@@ -265,7 +268,11 @@ internal ObservabilityConfig BuildConfig(string sdkKey)
                 sdkKey,
                 _extendedTracerConfiguration,
                 _extendedLoggerConfiguration,
-                _extendedMeterConfiguration);
+                _extendedMeterConfiguration
+#if !NETFRAMEWORK
+                , ConfigureLoggerOptions
+#endif
+            );
         }
     }
 }

sdk/@launchdarkly/observability-dotnet/src/LaunchDarkly.Observability/ObservabilityConfig.cs

@@ -7,6 +7,7 @@ namespace LaunchDarkly.Observability
 {
 #if NETFRAMEWORK
     using LoggerBuilderType = OpenTelemetryLoggerOptions;
+
 #else
     using LoggerBuilderType = LoggerProviderBuilder;
 #endif
@@ -60,6 +61,13 @@ public class ObservabilityConfig
         /// </summary>
         public Action<LoggerBuilderType> ExtendedLoggerConfiguration { get; }
 
+#if !NETFRAMEWORK
+        /// <summary>
+        /// Function which extends the options of the logger provider.
+        /// </summary>
+        public Action<OpenTelemetryLoggerOptions> ExtendedLoggerOptionsConfiguration { get; }
+#endif
+
         /// <summary>
         /// Function which extends the configuration of the meter provider.
         /// </summary>
@@ -75,6 +83,9 @@ internal ObservabilityConfig(
             Action<TracerProviderBuilder> extendedTracerConfiguration,
             Action<LoggerBuilderType> extendedLoggerConfiguration,
             Action<MeterProviderBuilder> extendedMeterConfiguration
+#if !NETFRAMEWORK
+            , Action<OpenTelemetryLoggerOptions> extendedLoggerOptionConfiguration
+#endif
         )
         {
             OtlpEndpoint = otlpEndpoint;
@@ -86,6 +97,9 @@ Action<MeterProviderBuilder> extendedMeterConfiguration
             ExtendedTracerConfiguration = extendedTracerConfiguration;
             ExtendedLoggerConfiguration = extendedLoggerConfiguration;
             ExtendedMeterConfiguration = extendedMeterConfiguration;
+#if !NETFRAMEWORK
+            ExtendedLoggerOptionsConfiguration = extendedLoggerOptionConfiguration;
+#endif
         }
 
         /// <summary>

sdk/@launchdarkly/observability-dotnet/test/LaunchDarkly.Observability.Tests/ObservabilityPluginBuilderTests.cs

@@ -1,6 +1,9 @@
 using NUnit.Framework;
 using System;
 using Microsoft.Extensions.DependencyInjection;
+#if !NETFRAMEWORK
+using OpenTelemetry.Logs;
+#endif
 
 namespace LaunchDarkly.Observability.Test
 {
@@ -115,5 +118,75 @@ public void Build_PrefersExplicitServiceName_OverEnvironmentVariable()
                 Environment.SetEnvironmentVariable(EnvironmentVariables.OtelServiceName, originalValue);
             }
         }
+
+#if !NETFRAMEWORK
+        [Test]
+        public void WithExtendedLoggerConfiguration_WithBothParameters_SetsConfigurationCorrectly()
+        {
+            Action<LoggerProviderBuilder> loggerConfig = _ => { };
+            Action<OpenTelemetryLoggerOptions> loggerOptions = _ => { };
+
+            var pluginBuilder = ObservabilityPlugin.Builder(_services)
+                .WithExtendedLoggerConfiguration(loggerConfig, loggerOptions);
+
+            var plugin = pluginBuilder.Build();
+
+            Assert.That(plugin, Is.Not.Null);
+            Assert.That(plugin, Is.InstanceOf<ObservabilityPlugin>());
+        }
+
+        [Test]
+        public void WithExtendedLoggerConfiguration_WithNullLoggerConfiguration_AcceptsNullValue()
+        {
+            Action<OpenTelemetryLoggerOptions> loggerOptions = _ => { };
+
+            var pluginBuilder = ObservabilityPlugin.Builder(_services)
+                .WithExtendedLoggerConfiguration(null, loggerOptions);
+
+            var plugin = pluginBuilder.Build();
+
+            Assert.That(plugin, Is.Not.Null);
+            Assert.That(plugin, Is.InstanceOf<ObservabilityPlugin>());
+        }
+
+        [Test]
+        public void WithExtendedLoggerConfiguration_WithNullLoggerOptions_AcceptsNullValue()
+        {
+            Action<LoggerProviderBuilder> loggerConfig = _ => { };
+
+            var pluginBuilder = ObservabilityPlugin.Builder(_services)
+                .WithExtendedLoggerConfiguration(loggerConfig, null);
+
+            var plugin = pluginBuilder.Build();
+
+            Assert.That(plugin, Is.Not.Null);
+            Assert.That(plugin, Is.InstanceOf<ObservabilityPlugin>());
+        }
+
+        [Test]
+        public void WithExtendedLoggerConfiguration_WithBothParametersNull_AcceptsNullValues()
+        {
+            var pluginBuilder = ObservabilityPlugin.Builder(_services)
+                .WithExtendedLoggerConfiguration(null, null);
+
+            var plugin = pluginBuilder.Build();
+
+            Assert.That(plugin, Is.Not.Null);
+            Assert.That(plugin, Is.InstanceOf<ObservabilityPlugin>());
+        }
+
+        [Test]
+        public void WithExtendedLoggerConfiguration_ReturnsBuilderInstance()
+        {
+            Action<LoggerProviderBuilder> loggerConfig = _ => { };
+            Action<OpenTelemetryLoggerOptions> loggerOptions = _ => { };
+
+            var result = ObservabilityPlugin.Builder(_services)
+                .WithExtendedLoggerConfiguration(loggerConfig, loggerOptions);
+
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result, Is.InstanceOf<ObservabilityPlugin.ObservabilityPluginBuilder>());
+        }
+#endif
     }
 }