Add setters for State, StateValues, and FormattedMessage fields for LogRecord.

docs/logs/extending-the-sdk/MyRedactionProcessor.cs

@@ -0,0 +1,54 @@
+// <copyright file="MyRedactionProcessor.cs" company="OpenTelemetry Authors">
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// </copyright>
+
+using System;
+using System.Collections.Generic;
+using OpenTelemetry;
+using OpenTelemetry.Logs;
+
+internal class MyRedactionProcessor : BaseProcessor<LogRecord>
+{
+    private readonly string name;
+
+    public MyRedactionProcessor(string name)
+    {
+        this.name = name;
+    }
+
+    public override void OnEnd(LogRecord logRecord)
+    {
+        var listKvp = logRecord.State as IReadOnlyList<KeyValuePair<string, object>>;
+        int kvpCount = listKvp == null ? 0 : listKvp.Count;
+
+        for (int i = 0; i < kvpCount; ++i)
+        {
+            var entry = listKvp[i];
+            if (kvpCount > 1 && StringComparer.Ordinal.Equals(entry.Key, "{OriginalFormat}"))
+            {
+                continue;
+            }
+
+            if (entry.Value is string str && str.Contains("sensitive information"))
+            {
+                Console.WriteLine($"{this.name}.OnEnd(LogRecord.State before redaction: {logRecord.State})");
+                logRecord.State = new List<KeyValuePair<string, object>> { new KeyValuePair<string, object>("newStateValueKey", "newStateValueValue") };
+
+                var newListKvp = logRecord.State as IReadOnlyList<KeyValuePair<string, object>>;
+                Console.WriteLine($"{this.name}.OnEnd(LogRecord.State after redaction: {newListKvp[0].Key}, {newListKvp[0].Value})");
+            }
+        }
+    }
+}

docs/logs/extending-the-sdk/Program.cs

@@ -31,6 +31,7 @@ public static void Main()
                 options.AddProcessor(new MyProcessor("ProcessorA"))
                        .AddProcessor(new MyProcessor("ProcessorB"))
                        .AddProcessor(new SimpleLogRecordExportProcessor(new MyExporter("ExporterX")))
+                       .AddProcessor(new MyRedactionProcessor("RedctionProcessor"))
                        .AddMyExporter();
             }));
 
@@ -64,6 +65,9 @@ public static void Main()
         {
             logger.LogError("{name} is broken.", "refrigerator");
         }
+
+        // message will be redacted by MyRedactionProcessor
+        logger.LogInformation("Message to log: {message}.", "sensitive information");
     }
 
     internal struct Food

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

@@ -1,6 +1,9 @@
 OpenTelemetry.BaseExporter<T>.ForceFlush(int timeoutMilliseconds = -1) -> bool
 OpenTelemetry.Batch<T>.Batch(T[] items, int count) -> void
 OpenTelemetry.Batch<T>.Count.get -> long
+OpenTelemetry.Logs.LogRecord.FormattedMessage.set -> void
+OpenTelemetry.Logs.LogRecord.State.set -> void
+OpenTelemetry.Logs.LogRecord.StateValues.set -> void
 OpenTelemetry.Metrics.ExplicitBucketHistogramConfiguration
 OpenTelemetry.Metrics.ExplicitBucketHistogramConfiguration.Boundaries.get -> double[]
 OpenTelemetry.Metrics.ExplicitBucketHistogramConfiguration.Boundaries.set -> void

src/OpenTelemetry/.publicApi/netstandard2.0/PublicAPI.Unshipped.txt

@@ -1,6 +1,9 @@
 OpenTelemetry.BaseExporter<T>.ForceFlush(int timeoutMilliseconds = -1) -> bool
 OpenTelemetry.Batch<T>.Batch(T[] items, int count) -> void
 OpenTelemetry.Batch<T>.Count.get -> long
+OpenTelemetry.Logs.LogRecord.FormattedMessage.set -> void
+OpenTelemetry.Logs.LogRecord.State.set -> void
+OpenTelemetry.Logs.LogRecord.StateValues.set -> void
 OpenTelemetry.Metrics.ExplicitBucketHistogramConfiguration
 OpenTelemetry.Metrics.ExplicitBucketHistogramConfiguration.Boundaries.get -> double[]
 OpenTelemetry.Metrics.ExplicitBucketHistogramConfiguration.Boundaries.set -> void

src/OpenTelemetry/CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## Unreleased
 
+* Add setters for `State`, `StateValues`, and `FormattedMessage` for LogRecord.
+  ([2864](https://github.com/open-telemetry/opentelemetry-dotnet/pull/2864))
+
 ## 1.2.0-rc5
 
 Released 2022-Apr-12

src/OpenTelemetry/Logs/LogRecord.cs

@@ -81,21 +81,21 @@ internal LogRecord(
 
         public EventId EventId { get; }
 
-        public string FormattedMessage { get; }
+        public string FormattedMessage { get; set; }
 
         /// <summary>
-        /// Gets the raw state attached to the log. Set to <see
+        /// Gets or sets the raw state attached to the log. Set to <see
         /// langword="null"/> when <see
         /// cref="OpenTelemetryLoggerOptions.ParseStateValues"/> is enabled.
         /// </summary>
-        public object State { get; }
+        public object State { get; set; }
 
         /// <summary>
-        /// Gets the parsed state values attached to the log. Set when <see
+        /// Gets or sets the parsed state values attached to the log. Set when <see
         /// cref="OpenTelemetryLoggerOptions.ParseStateValues"/> is enabled
         /// otherwise <see langword="null"/>.
         /// </summary>
-        public IReadOnlyList<KeyValuePair<string, object>> StateValues { get; }
+        public IReadOnlyList<KeyValuePair<string, object>> StateValues { get; set; }
 
         public Exception Exception { get; }
 

test/OpenTelemetry.Tests/Logs/LogRecordTest.cs

@@ -33,6 +33,13 @@ namespace OpenTelemetry.Logs.Tests
 {
     public sealed class LogRecordTest
     {
+        private enum Field
+        {
+            FormattedMessage,
+            State,
+            StateValues,
+        }
+
         [Fact]
         public void CheckCategoryNameForLog()
         {
@@ -243,6 +250,122 @@ public void CheckStateForExceptionLogged()
             Assert.Equal(message, state.ToString());
         }
 
+        [Fact]
+        public void CheckStateCanBeSet()
+        {
+            using var loggerFactory = InitializeLoggerFactory(out List<LogRecord> exportedItems, configure: null);
+            var logger = loggerFactory.CreateLogger<LogRecordTest>();
+
+            var message = $"This does not matter.";
+            logger.LogInformation(message);
+
+            var logRecord = exportedItems[0];
+            logRecord.State = "newState";
+
+            var expectedState = "newState";
+            Assert.Equal(expectedState, logRecord.State);
+        }
+
+        [Fact]
+        public void CheckStateValuesCanBeSet()
+        {
+            using var loggerFactory = InitializeLoggerFactory(out List<LogRecord> exportedItems, configure: options => options.ParseStateValues = true);
+            var logger = loggerFactory.CreateLogger<LogRecordTest>();
+
+            logger.Log(
+                LogLevel.Information,
+                0,
+                new List<KeyValuePair<string, object>> { new KeyValuePair<string, object>("Key1", "Value1") },
+                null,
+                (s, e) => "OpenTelemetry!");
+
+            var logRecord = exportedItems[0];
+            var expectedStateValues = new List<KeyValuePair<string, object>> { new KeyValuePair<string, object>("Key2", "Value2") };
+            logRecord.StateValues = expectedStateValues;
+
+            Assert.Equal(expectedStateValues, logRecord.StateValues);
+        }
+
+        [Fact]
+        public void CheckFormattedMessageCanBeSet()
+        {
+            using var loggerFactory = InitializeLoggerFactory(out List<LogRecord> exportedItems, configure: options => options.IncludeFormattedMessage = true);
+            var logger = loggerFactory.CreateLogger<LogRecordTest>();
+
+            logger.LogInformation("OpenTelemetry {Greeting} {Subject}!", "Hello", "World");
+            var logRecord = exportedItems[0];
+            var expectedFormattedMessage = "OpenTelemetry Good Night!";
+            logRecord.FormattedMessage = expectedFormattedMessage;
+
+            Assert.Equal(expectedFormattedMessage, logRecord.FormattedMessage);
+        }
+
+        [Fact]
+        public void CheckStateCanBeSetByProcessor()
+        {
+            var exportedItems = new List<LogRecord>();
+            var exporter = new InMemoryExporter<LogRecord>(exportedItems);
+            using var loggerFactory = LoggerFactory.Create(builder =>
+            {
+                builder.AddOpenTelemetry(options =>
+                {
+                    options.AddProcessor(new RedactionProcessor(Field.State));
+                    options.AddInMemoryExporter(exportedItems);
+                });
+            });
+
+            var logger = loggerFactory.CreateLogger<LogRecordTest>();
+            logger.LogInformation($"This does not matter.");
+
+            var state = exportedItems[0].State as IReadOnlyList<KeyValuePair<string, object>>;
+            Assert.Equal("newStateKey", state[0].Key.ToString());
+            Assert.Equal("newStateValue", state[0].Value.ToString());
+        }
+
+        [Fact]
+        public void CheckStateValuesCanBeSetByProcessor()
+        {
+            var exportedItems = new List<LogRecord>();
+            var exporter = new InMemoryExporter<LogRecord>(exportedItems);
+            using var loggerFactory = LoggerFactory.Create(builder =>
+            {
+                builder.AddOpenTelemetry(options =>
+                {
+                    options.AddProcessor(new RedactionProcessor(Field.StateValues));
+                    options.AddInMemoryExporter(exportedItems);
+                    options.ParseStateValues = true;
+                });
+            });
+
+            var logger = loggerFactory.CreateLogger<LogRecordTest>();
+            logger.LogInformation("This does not matter.");
+
+            var stateValue = exportedItems[0];
+            Assert.Equal(new KeyValuePair<string, object>("newStateValueKey", "newStateValueValue"), stateValue.StateValues[0]);
+        }
+
+        [Fact]
+        public void CheckFormattedMessageCanBeSetByProcessor()
+        {
+            var exportedItems = new List<LogRecord>();
+            var exporter = new InMemoryExporter<LogRecord>(exportedItems);
+            using var loggerFactory = LoggerFactory.Create(builder =>
+            {
+                builder.AddOpenTelemetry(options =>
+                {
+                    options.AddProcessor(new RedactionProcessor(Field.FormattedMessage));
+                    options.AddInMemoryExporter(exportedItems);
+                    options.IncludeFormattedMessage = true;
+                });
+            });
+
+            var logger = loggerFactory.CreateLogger<LogRecordTest>();
+            logger.LogInformation("OpenTelemetry {Greeting} {Subject}!", "Hello", "World");
+
+            var item = exportedItems[0];
+            Assert.Equal("OpenTelemetry Good Night!", item.FormattedMessage);
+        }
+
         [Fact]
         public void CheckTraceIdForLogWithinDroppedActivity()
         {
@@ -668,6 +791,32 @@ IEnumerator IEnumerable.GetEnumerator()
             }
         }
 
+        private class RedactionProcessor : BaseProcessor<LogRecord>
+        {
+            private readonly Field fieldToUpdate;
+
+            public RedactionProcessor(Field fieldToUpdate)
+            {
+                this.fieldToUpdate = fieldToUpdate;
+            }
+
+            public override void OnEnd(LogRecord logRecord)
+            {
+                if (this.fieldToUpdate == Field.State)
+                {
+                    logRecord.State = new List<KeyValuePair<string, object>> { new KeyValuePair<string, object>("newStateKey", "newStateValue") };
+                }
+                else if (this.fieldToUpdate == Field.StateValues)
+                {
+                    logRecord.StateValues = new List<KeyValuePair<string, object>> { new KeyValuePair<string, object>("newStateValueKey", "newStateValueValue") };
+                }
+                else
+                {
+                    logRecord.FormattedMessage = "OpenTelemetry Good Night!";
+                }
+            }
+        }
+
         private class ListState : IEnumerable<KeyValuePair<string, object>>
         {
             private readonly List<KeyValuePair<string, object>> list;