[Extensions] Adds BaggageLogRecordProcessor

src/OpenTelemetry.Extensions/.publicApi/PublicAPI.Unshipped.txt

@@ -14,6 +14,8 @@ OpenTelemetry.Trace.BaggageActivityProcessor
 OpenTelemetry.Trace.TracerProviderBuilderExtensions
 override OpenTelemetry.RateLimitingSampler.ShouldSample(in OpenTelemetry.Trace.SamplingParameters samplingParameters) -> OpenTelemetry.Trace.SamplingResult
 override OpenTelemetry.Trace.BaggageActivityProcessor.OnStart(System.Diagnostics.Activity! data) -> void
+static Microsoft.Extensions.Logging.OpenTelemetryLoggingExtensions.AddBaggageProcessor(this OpenTelemetry.Logs.OpenTelemetryLoggerOptions! loggerOptions) -> OpenTelemetry.Logs.OpenTelemetryLoggerOptions!
+static Microsoft.Extensions.Logging.OpenTelemetryLoggingExtensions.AddBaggageProcessor(this OpenTelemetry.Logs.OpenTelemetryLoggerOptions! loggerOptions, System.Predicate<string!>! baggageKeyPredicate) -> OpenTelemetry.Logs.OpenTelemetryLoggerOptions!
 static Microsoft.Extensions.Logging.OpenTelemetryLoggingExtensions.AttachLogsToActivityEvent(this OpenTelemetry.Logs.OpenTelemetryLoggerOptions! loggerOptions, System.Action<OpenTelemetry.Logs.LogToActivityEventConversionOptions!>? configure = null) -> OpenTelemetry.Logs.OpenTelemetryLoggerOptions!
 static OpenTelemetry.Trace.BaggageActivityProcessor.AllowAllBaggageKeys.get -> System.Predicate<string!>!
 static OpenTelemetry.Trace.TracerProviderBuilderExtensions.AddAutoFlushActivityProcessor(this OpenTelemetry.Trace.TracerProviderBuilder! builder, System.Func<System.Diagnostics.Activity!, bool>! predicate, int timeoutMilliseconds = 10000) -> OpenTelemetry.Trace.TracerProviderBuilder!

src/OpenTelemetry.Extensions/CHANGELOG.md

@@ -19,6 +19,9 @@ rate per second. For details see
 * Updated OpenTelemetry core component version(s) to `1.10.0`.
   ([#2317](https://github.com/open-telemetry/opentelemetry-dotnet-contrib/pull/2317))
 
+* Adds Baggage LogRecord Processor.
+  ([#2354](https://github.com/open-telemetry/opentelemetry-dotnet-contrib/pull/2354))
+
 ## 1.0.0-beta.5
 
 Released 2024-May-08

src/OpenTelemetry.Extensions/Internal/BaggageLogRecordProcessor.cs

@@ -0,0 +1,43 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+using OpenTelemetry.Logs;
+
+namespace OpenTelemetry.Extensions.Internal;
+
+internal sealed class BaggageLogRecordProcessor : BaseProcessor<LogRecord>
+{
+    private readonly Predicate<string> baggageKeyPredicate;
+
+    public BaggageLogRecordProcessor(Predicate<string> baggageKeyPredicate)
+    {
+        this.baggageKeyPredicate = baggageKeyPredicate ?? throw new ArgumentNullException(nameof(baggageKeyPredicate));
+    }
+
+    public static Predicate<string> AllowAllBaggageKeys => (_) => true;
+
+    public override void OnEnd(LogRecord data)
+    {
+        if (data != null)
+        {
+            var attributes = new List<KeyValuePair<string, object?>>();
+
+            foreach (var entry in Baggage.Current)
+            {
+                if (this.baggageKeyPredicate(entry.Key))
+                {
+                    attributes.Add(new(entry.Key, entry.Value));
+                }
+            }
+
+            if (data.Attributes != null)
+            {
+                attributes.AddRange(data.Attributes);
+            }
+
+            data.Attributes = attributes;
+        }
+
+        base.OnEnd(data!);
+    }
+}

src/OpenTelemetry.Extensions/Internal/OpenTelemetryExtensionsEventSource.cs

@@ -45,8 +45,14 @@ public void LogRecordFilterException(string? categoryName, string exception)
     }
 
     [Event(3, Message = "Baggage key predicate threw exeption when trying to add baggage entry with key '{0}'. Baggage entry will not be added to the activity. Exception: '{1}'", Level = EventLevel.Warning)]
-    public void BaggageKeyPredicateException(string baggageKey, string exception)
+    public void BaggageKeyActivityPredicateException(string baggageKey, string exception)
     {
         this.WriteEvent(3, baggageKey, exception);
     }
+
+    [Event(4, Message = "Baggage key predicate threw exeption when trying to add baggage entry with key '{0}'. Baggage entry will not be added to the log record. Exception: '{1}'", Level = EventLevel.Warning)]
+    public void BaggageKeyLogRecordPredicateException(string baggageKey, string exception)
+    {
+        this.WriteEvent(4, baggageKey, exception);
+    }
 }

src/OpenTelemetry.Extensions/Logs/OpenTelemetryLoggingExtensions.cs

@@ -2,6 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 using System.Diagnostics;
+using OpenTelemetry;
+using OpenTelemetry.Extensions.Internal;
 using OpenTelemetry.Internal;
 using OpenTelemetry.Logs;
 
@@ -34,4 +36,45 @@ public static OpenTelemetryLoggerOptions AttachLogsToActivityEvent(
         return loggerOptions.AddProcessor(new ActivityEventAttachingLogProcessor(options));
 #pragma warning restore CA2000 // Dispose objects before losing scope
     }
+
+    /// <summary>
+    /// Adds the <see cref="BaggageLogRecordProcessor"/> to the <see cref="OpenTelemetryLoggerOptions"/>.
+    /// </summary>
+    /// <param name="loggerOptions"><see cref="OpenTelemetryLoggerOptions"/> to add the <see cref="BaggageLogRecordProcessor"/> to.</param>
+    /// <returns>The instance of <see cref="OpenTelemetryLoggerOptions"/> to chain the calls.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="loggerOptions"/> is <c>null</c>.</exception>
+    public static OpenTelemetryLoggerOptions AddBaggageProcessor(
+        this OpenTelemetryLoggerOptions loggerOptions)
+    {
+        return loggerOptions.AddBaggageProcessor(BaggageLogRecordProcessor.AllowAllBaggageKeys);
+    }
+
+    /// <summary>
+    /// Adds the <see cref="BaggageLogRecordProcessor"/> to the <see cref="OpenTelemetryLoggerOptions"/>.
+    /// </summary>
+    /// <param name="loggerOptions"><see cref="OpenTelemetryLoggerOptions"/> to add the <see cref="BaggageLogRecordProcessor"/> to.</param>
+    /// <param name="baggageKeyPredicate">Predicate to determine which baggage keys should be added to the log record.</param>
+    /// <returns>The instance of <see cref="OpenTelemetryLoggerOptions"/> to chain the calls.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="loggerOptions"/> is <c>null</c>.</exception>
+    /// <exception cref="ArgumentNullException"><paramref name="baggageKeyPredicate"/> is <c>null</c>.</exception>
+    public static OpenTelemetryLoggerOptions AddBaggageProcessor(
+        this OpenTelemetryLoggerOptions loggerOptions,
+        Predicate<string> baggageKeyPredicate)
+    {
+        Guard.ThrowIfNull(loggerOptions);
+        Guard.ThrowIfNull(baggageKeyPredicate);
+
+        return loggerOptions.AddProcessor(b => new BaggageLogRecordProcessor(baggageKey =>
+        {
+            try
+            {
+                return baggageKeyPredicate(baggageKey);
+            }
+            catch (Exception exception)
+            {
+                OpenTelemetryExtensionsEventSource.Log.BaggageKeyLogRecordPredicateException(baggageKey, exception.Message);
+                return false;
+            }
+        }));
+    }
 }

src/OpenTelemetry.Extensions/README.md

@@ -20,6 +20,25 @@ future.
 Adds a log processor which will convert log messages into events and attach them
 to the currently running `Activity`.
 
+### AddBaggageProcessor
+
+Adds a log processor which will copy baggage entries to log records.
+The method takes an optional predicate to filter the copied baggage entries
+based on the entry key. If no predicate is provided, all entries are copied.
+
+Example of AddBaggageProcessor usage with a predicate:
+
+```csharp
+var regex = new Regex("^allow", RegexOptions.Compiled);
+var logRecordList = new List<LogRecord>();
+using var loggerFactory = LoggerFactory.Create(builder => builder
+.AddOpenTelemetry(options =>
+{
+    options.AddBaggageProcessor(regex.IsMatch);
+    // other set up (exporters, processors)
+})
+```
+
 ## Traces
 
 ### AutoFlushActivityProcessor

src/OpenTelemetry.Extensions/TracerProviderBuilderExtensions.cs

@@ -68,7 +68,7 @@ public static TracerProviderBuilder AddBaggageActivityProcessor(
             }
             catch (Exception exception)
             {
-                OpenTelemetryExtensionsEventSource.Log.BaggageKeyPredicateException(baggageKey, exception.Message);
+                OpenTelemetryExtensionsEventSource.Log.BaggageKeyActivityPredicateException(baggageKey, exception.Message);
                 return false;
             }
         }));

test/OpenTelemetry.Extensions.Tests/Logs/BaggageLogRecordProcessorTests.cs

@@ -0,0 +1,134 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+using System.Runtime.CompilerServices;
+using System.Text.RegularExpressions;
+using Microsoft.Extensions.Logging;
+using OpenTelemetry.Logs;
+using OpenTelemetry.Trace;
+using Xunit;
+
+namespace OpenTelemetry.Extensions.Tests.Logs;
+
+public class BaggageLogRecordProcessorTests
+{
+    [Fact]
+    public void BaggageLogRecordProcessor_CanAddAllowAllBaggageKeysPredicate()
+    {
+        var logRecordList = new List<LogRecord>();
+        using var loggerFactory = LoggerFactory.Create(builder => builder
+        .AddOpenTelemetry(options =>
+        {
+            options.AddBaggageProcessor();
+            options.AddInMemoryExporter(logRecordList);
+        })
+        .AddFilter("*", LogLevel.Trace)); // Enable all LogLevels
+        Baggage.SetBaggage("allow", "value");
+
+        var logger = loggerFactory.CreateLogger(GetTestMethodName());
+        logger.LogError("this does not matter");
+        var logRecord = Assert.Single(logRecordList);
+        Assert.NotNull(logRecord);
+        Assert.NotNull(logRecord.Attributes);
+        Assert.Contains(logRecord.Attributes, kv => kv.Key == "allow");
+    }
+
+    [Fact]
+    public void BaggageLogRecordProcessor_CanUseCustomPredicate()
+    {
+        var logRecordList = new List<LogRecord>();
+        using var loggerFactory = LoggerFactory.Create(builder => builder
+        .AddOpenTelemetry(options =>
+        {
+            options.AddBaggageProcessor((baggageKey) => baggageKey.StartsWith("allow", StringComparison.Ordinal));
+            options.AddInMemoryExporter(logRecordList);
+        })
+        .AddFilter("*", LogLevel.Trace)); // Enable all LogLevels
+        Baggage.SetBaggage("allow", "value");
+        Baggage.SetBaggage("deny", "other_value");
+
+        var logger = loggerFactory.CreateLogger(GetTestMethodName());
+        logger.LogError("this does not matter");
+        var logRecord = Assert.Single(logRecordList);
+        Assert.NotNull(logRecord);
+        Assert.NotNull(logRecord.Attributes);
+        Assert.Contains(logRecord.Attributes, kv => kv.Key == "allow");
+        Assert.DoesNotContain(logRecord.Attributes, kv => kv.Key == "deny");
+    }
+
+    [Fact]
+    public void BaggageLogRecordProcessor_CanUseRegex()
+    {
+        var regex = new Regex("^allow", RegexOptions.Compiled);
+        var logRecordList = new List<LogRecord>();
+        using var loggerFactory = LoggerFactory.Create(builder => builder
+        .AddOpenTelemetry(options =>
+        {
+            options.AddBaggageProcessor(regex.IsMatch);
+            options.AddInMemoryExporter(logRecordList);
+        })
+        .AddFilter("*", LogLevel.Trace)); // Enable all LogLevels
+        Baggage.SetBaggage("allow", "value");
+        Baggage.SetBaggage("deny", "other_value");
+
+        var logger = loggerFactory.CreateLogger(GetTestMethodName());
+        logger.LogError("this does not matter");
+        var logRecord = Assert.Single(logRecordList);
+        Assert.NotNull(logRecord);
+        Assert.NotNull(logRecord.Attributes);
+        Assert.Contains(logRecord.Attributes, kv => kv.Key == "allow");
+        Assert.DoesNotContain(logRecord.Attributes, kv => kv.Key == "deny");
+    }
+
+    [Fact]
+    public void BaggageLogRecordProcessor_PredicateThrows_DoesNothing()
+    {
+        var logRecordList = new List<LogRecord>();
+        using var loggerFactory = LoggerFactory.Create(builder => builder
+        .AddOpenTelemetry(options =>
+        {
+            options.AddBaggageProcessor(_ => throw new Exception("Predicate throws an exception."));
+            options.AddInMemoryExporter(logRecordList);
+        })
+        .AddFilter("*", LogLevel.Trace)); // Enable all LogLevels
+        Baggage.SetBaggage("deny", "value");
+
+        var logger = loggerFactory.CreateLogger(GetTestMethodName());
+        logger.LogError("this does not matter");
+        var logRecord = Assert.Single(logRecordList);
+        Assert.NotNull(logRecord);
+        Assert.DoesNotContain(logRecord?.Attributes ?? [], kv => kv.Key == "deny");
+    }
+
+    [Fact]
+    public void BaggageLogRecordProcessor_PredicateThrows_OnlyDropsEntriesThatThrow()
+    {
+        var logRecordList = new List<LogRecord>();
+        using var loggerFactory = LoggerFactory.Create(builder => builder
+        .AddOpenTelemetry(options =>
+        {
+            options.AddBaggageProcessor(key =>
+            {
+                return key != "allow" ? throw new Exception("Predicate throws an exception.") : true;
+            });
+            options.AddInMemoryExporter(logRecordList);
+        })
+        .AddFilter("*", LogLevel.Trace)); // Enable all LogLevels
+        Baggage.SetBaggage("allow", "value");
+        Baggage.SetBaggage("deny", "value");
+        Baggage.SetBaggage("deny_2", "value");
+
+        var logger = loggerFactory.CreateLogger(GetTestMethodName());
+        logger.LogError("this does not matter");
+        var logRecord = Assert.Single(logRecordList);
+        Assert.NotNull(logRecord);
+        Assert.NotNull(logRecord.Attributes);
+        Assert.Contains(logRecord.Attributes, kv => kv.Key == "allow");
+        Assert.DoesNotContain(logRecord?.Attributes ?? [], kv => kv.Key == "deny");
+    }
+
+    private static string GetTestMethodName([CallerMemberName] string callingMethodName = "")
+    {
+        return callingMethodName;
+    }
+}

test/OpenTelemetry.Extensions.Tests/OpenTelemetry.Extensions.Tests.csproj

@@ -15,4 +15,8 @@
     <Compile Include="$(RepoRoot)\test\Shared\TestActivityProcessor.cs" Link="Includes\TestActivityProcessor.cs" />
   </ItemGroup>
 
+  <ItemGroup>
+    <PackageReference Include="OpenTelemetry.Exporter.InMemory" Version="$(OpenTelemetryCoreLatestVersion)" />
+  </ItemGroup>
+
 </Project>