open-telemetry · CodeBlanch · May 24, 2022 · May 25, 2022 · May 26, 2022 · May 26, 2022
@@ -233,7 +233,9 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "OpenTelemetry.Extensions.Pr
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "OpenTelemetry.Extensions.Propagators.Tests", "test\OpenTelemetry.Extensions.Propagators.Tests\OpenTelemetry.Extensions.Propagators.Tests.csproj", "{476D804B-BFEC-4D34-814C-DFFD97109989}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "correlation", "docs\logs\correlation\correlation.csproj", "{9A07D215-90AC-4BAF-BCDB-73D74FD3A5C5}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "correlation", "docs\logs\correlation\correlation.csproj", "{9A07D215-90AC-4BAF-BCDB-73D74FD3A5C5}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "OpenTelemetry.Tests.Stress.Logs", "test\OpenTelemetry.Tests.Stress.Logs\OpenTelemetry.Tests.Stress.Logs.csproj", "{5FC0660F-3757-4594-806B-4375E06177A3}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -493,6 +495,10 @@ Global
 		{9A07D215-90AC-4BAF-BCDB-73D74FD3A5C5}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{9A07D215-90AC-4BAF-BCDB-73D74FD3A5C5}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{9A07D215-90AC-4BAF-BCDB-73D74FD3A5C5}.Release|Any CPU.Build.0 = Release|Any CPU
+		{5FC0660F-3757-4594-806B-4375E06177A3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{5FC0660F-3757-4594-806B-4375E06177A3}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{5FC0660F-3757-4594-806B-4375E06177A3}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{5FC0660F-3757-4594-806B-4375E06177A3}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

@@ -16,24 +16,30 @@
 
 namespace Examples.AspNetCore.Controllers;
 
+using System.Diagnostics;
 using Microsoft.AspNetCore.Mvc;
+using OpenTelemetry.Logs;
 
 [ApiController]
 [Route("[controller]")]
 public class WeatherForecastController : ControllerBase
 {
     private static readonly string[] Summaries = new[]
     {
-            "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching",
+        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching",
     };
 
     private static readonly HttpClient HttpClient = new();
 
     private readonly ILogger<WeatherForecastController> logger;
+    private readonly LogEmitter logEmitter;
 
-    public WeatherForecastController(ILogger<WeatherForecastController> logger)
+    public WeatherForecastController(
+        ILogger<WeatherForecastController> logger,
+        LogEmitter logEmitter)
     {
         this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
+        this.logEmitter = logEmitter ?? throw new ArgumentNullException(nameof(logEmitter));
     }
 
     [HttpGet]
@@ -54,11 +60,25 @@ public IEnumerable<WeatherForecast> Get()
         })
         .ToArray();
 
+        // Log using ILogger API.
         this.logger.LogInformation(
             "WeatherForecasts generated {count}: {forecasts}",
             forecast.Length,
             forecast);
 
+        // Log using LogEmitter API.
+        this.logEmitter.Log(
+            new LogRecordData(Activity.Current)
+            {
+                CategoryName = "WeatherForecasts",
+                LogLevel = LogLevel.Information,
+                Message = "WeatherForecasts generated.",
+            },
+            new LogRecordAttributeList()
+            {
+                ["count"] = forecast.Length,
+            });
+
         return forecast;
     }
 }
diff --git a/src/OpenTelemetry.Exporter.Console/ConsoleLogRecordExporter.cs b/src/OpenTelemetry.Exporter.Console/ConsoleLogRecordExporter.cs
@@ -42,7 +42,11 @@ public override ExportResult Export(in Batch<LogRecord> batch)
                     this.WriteLine($"{"LogRecord.TraceFlags:",-RightPaddingLength}{logRecord.TraceFlags}");
                 }
 
-                this.WriteLine($"{"LogRecord.CategoryName:",-RightPaddingLength}{logRecord.CategoryName}");
+                if (logRecord.CategoryName != null)
+                {
+                    this.WriteLine($"{"LogRecord.CategoryName:",-RightPaddingLength}{logRecord.CategoryName}");
+                }
+
                 this.WriteLine($"{"LogRecord.LogLevel:",-RightPaddingLength}{logRecord.LogLevel}");
 
                 if (logRecord.FormattedMessage != null)

diff --git a/src/OpenTelemetry.Exporter.InMemory/InMemoryExporter.cs b/src/OpenTelemetry.Exporter.InMemory/InMemoryExporter.cs
@@ -14,7 +14,6 @@
 // limitations under the License.
 // </copyright>
 
-using System;
 using System.Collections.Generic;
 
 namespace OpenTelemetry.Exporter
@@ -23,19 +22,21 @@ public class InMemoryExporter<T> : BaseExporter<T>
         where T : class
     {
         private readonly ICollection<T> exportedItems;
-        private readonly Func<Batch<T>, ExportResult> onExport;
+        private readonly ExportFunc onExport;
 
         public InMemoryExporter(ICollection<T> exportedItems)
         {
             this.exportedItems = exportedItems;
-            this.onExport = (Batch<T> batch) => this.DefaultExport(batch);
+            this.onExport = (in Batch<T> batch) => this.DefaultExport(in batch);
         }
 
-        internal InMemoryExporter(Func<Batch<T>, ExportResult> exportFunc)
+        internal InMemoryExporter(ExportFunc exportFunc)
         {
             this.onExport = exportFunc;
         }
 
+        internal delegate ExportResult ExportFunc(in Batch<T> batch);
+
         public override ExportResult Export(in Batch<T> batch) => this.onExport(batch);
 
         private ExportResult DefaultExport(in Batch<T> batch)

diff --git a/src/OpenTelemetry.Exporter.InMemory/InMemoryExporterLoggingExtensions.cs b/src/OpenTelemetry.Exporter.InMemory/InMemoryExporterLoggingExtensions.cs
@@ -27,7 +27,35 @@ public static OpenTelemetryLoggerOptions AddInMemoryExporter(this OpenTelemetryL
             Guard.ThrowIfNull(loggerOptions);
             Guard.ThrowIfNull(exportedItems);
 
-            return loggerOptions.AddProcessor(new SimpleLogRecordExportProcessor(new InMemoryExporter<LogRecord>(exportedItems)));
+            var logExporter = new InMemoryExporter<LogRecord>(
+                exportFunc: (in Batch<LogRecord> batch) => ExportLogRecord(in batch, exportedItems));
+
+            return loggerOptions.AddProcessor(new SimpleLogRecordExportProcessor(logExporter));
+        }
+
+        private static ExportResult ExportLogRecord(in Batch<LogRecord> batch, ICollection<LogRecord> exportedItems)
+        {
+            if (exportedItems == null)
+            {
+                return ExportResult.Failure;
+            }
+
+            foreach (var log in batch)
+            {
+                log.Buffer();
+
+                LogRecord copy = new()
+                {
+                    Data = log.Data,
+                    State = log.State,
+                    StateValues = log.StateValues == null ? null : new List<KeyValuePair<string, object>>(log.StateValues),
+                    BufferedScopes = log.BufferedScopes == null ? null : new List<object>(log.BufferedScopes),
+                };
+
+                exportedItems.Add(copy);
+            }
+
+            return ExportResult.Success;
         }
     }
 }
diff --git a/src/OpenTelemetry.Exporter.InMemory/InMemoryExporterMetricsExtensions.cs b/src/OpenTelemetry.Exporter.InMemory/InMemoryExporterMetricsExtensions.cs
@@ -145,7 +145,7 @@ private static MeterProviderBuilder AddInMemoryExporter(
             configureMetricReader?.Invoke(metricReaderOptions);
 
             var metricExporter = new InMemoryExporter<Metric>(
-                exportFunc: metricBatch => ExportMetricSnapshot(metricBatch, exportedItems));
+                exportFunc: (in Batch<Metric> metricBatch) => ExportMetricSnapshot(in metricBatch, exportedItems));
 
             var metricReader = PeriodicExportingMetricReaderHelper.CreatePeriodicExportingMetricReader(
                 metricExporter,

diff --git a/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/LogRecordExtensions.cs b/src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/LogRecordExtensions.cs
@@ -65,30 +65,31 @@ internal static void AddBatch(
         internal static OtlpLogs.LogRecord ToOtlpLog(this LogRecord logRecord)
         {
             OtlpLogs.LogRecord otlpLogRecord = null;
+            ref LogRecordData data = ref logRecord.GetDataRef();
 
             try
             {
                 otlpLogRecord = new OtlpLogs.LogRecord
                 {
-                    TimeUnixNano = (ulong)logRecord.Timestamp.ToUnixTimeNanoseconds(),
-                    SeverityNumber = GetSeverityNumber(logRecord.LogLevel),
-                    SeverityText = LogLevels[(int)logRecord.LogLevel],
+                    TimeUnixNano = (ulong)data.Timestamp.ToUnixTimeNanoseconds(),
+                    SeverityNumber = GetSeverityNumber(data.LogLevel),
+                    SeverityText = LogLevels[(int)data.LogLevel],
                 };
 
-                if (!string.IsNullOrEmpty(logRecord.CategoryName))
+                if (!string.IsNullOrEmpty(data.CategoryName))
                 {
                     // TODO:
                     // 1. Track the following issue, and map CategoryName to Name
                     // if it makes it to log data model.
                     // https://github.com/open-telemetry/opentelemetry-specification/issues/2398
                     // 2. Confirm if this name for attribute is good.
-                    otlpLogRecord.Attributes.AddStringAttribute("dotnet.ilogger.category", logRecord.CategoryName);
+                    otlpLogRecord.Attributes.AddStringAttribute("dotnet.ilogger.category", data.CategoryName);
                 }
 
                 bool bodyPopulatedFromFormattedMessage = false;
-                if (logRecord.FormattedMessage != null)
+                if (data.Message != null)
                 {
-                    otlpLogRecord.Body = new OtlpCommon.AnyValue { StringValue = logRecord.FormattedMessage };
+                    otlpLogRecord.Body = new OtlpCommon.AnyValue { StringValue = data.Message };
                     bodyPopulatedFromFormattedMessage = true;
                 }
 
@@ -110,34 +111,34 @@ internal static OtlpLogs.LogRecord ToOtlpLog(this LogRecord logRecord)
                     }
                 }
 
-                if (logRecord.EventId.Id != default)
+                if (data.EventId.Id != default)
                 {
-                    otlpLogRecord.Attributes.AddIntAttribute(nameof(logRecord.EventId.Id), logRecord.EventId.Id);
+                    otlpLogRecord.Attributes.AddIntAttribute(nameof(data.EventId.Id), data.EventId.Id);
                 }
 
-                if (!string.IsNullOrEmpty(logRecord.EventId.Name))
+                if (!string.IsNullOrEmpty(data.EventId.Name))
                 {
-                    otlpLogRecord.Attributes.AddStringAttribute(nameof(logRecord.EventId.Name), logRecord.EventId.Name);
+                    otlpLogRecord.Attributes.AddStringAttribute(nameof(data.EventId.Name), data.EventId.Name);
                 }
 
-                if (logRecord.Exception != null)
+                if (data.Exception != null)
                 {
-                    otlpLogRecord.Attributes.AddStringAttribute(SemanticConventions.AttributeExceptionType, logRecord.Exception.GetType().Name);
-                    otlpLogRecord.Attributes.AddStringAttribute(SemanticConventions.AttributeExceptionMessage, logRecord.Exception.Message);
-                    otlpLogRecord.Attributes.AddStringAttribute(SemanticConventions.AttributeExceptionStacktrace, logRecord.Exception.ToInvariantString());
+                    otlpLogRecord.Attributes.AddStringAttribute(SemanticConventions.AttributeExceptionType, data.Exception.GetType().Name);
+                    otlpLogRecord.Attributes.AddStringAttribute(SemanticConventions.AttributeExceptionMessage, data.Exception.Message);
+                    otlpLogRecord.Attributes.AddStringAttribute(SemanticConventions.AttributeExceptionStacktrace, data.Exception.ToInvariantString());
                 }
 
-                if (logRecord.TraceId != default && logRecord.SpanId != default)
+                if (data.TraceId != default && data.SpanId != default)
                 {
                     byte[] traceIdBytes = new byte[16];
                     byte[] spanIdBytes = new byte[8];
 
-                    logRecord.TraceId.CopyTo(traceIdBytes);
-                    logRecord.SpanId.CopyTo(spanIdBytes);
+                    data.TraceId.CopyTo(traceIdBytes);
+                    data.SpanId.CopyTo(spanIdBytes);
 
                     otlpLogRecord.TraceId = UnsafeByteOperations.UnsafeWrap(traceIdBytes);
                     otlpLogRecord.SpanId = UnsafeByteOperations.UnsafeWrap(spanIdBytes);
-                    otlpLogRecord.Flags = (uint)logRecord.TraceFlags;
+                    otlpLogRecord.Flags = (uint)data.TraceFlags;
                 }
 
                 int scopeDepth = -1;

diff --git a/src/OpenTelemetry/.publicApi/net462/PublicAPI.Shipped.txt b/src/OpenTelemetry/.publicApi/net462/PublicAPI.Shipped.txt
@@ -17,22 +17,22 @@ OpenTelemetry.BaseProcessor<T>.Dispose() -> void
 OpenTelemetry.BaseProcessor<T>.ForceFlush(int timeoutMilliseconds = -1) -> bool
 ~OpenTelemetry.BaseProcessor<T>.ParentProvider.get -> OpenTelemetry.BaseProvider
 OpenTelemetry.BaseProcessor<T>.Shutdown(int timeoutMilliseconds = -1) -> bool
-~OpenTelemetry.Batch<T>
+OpenTelemetry.Batch<T>
 OpenTelemetry.Batch<T>.Batch() -> void
-~OpenTelemetry.Batch<T>.Batch(T[] items, int count) -> void
+OpenTelemetry.Batch<T>.Batch(T![]! items, int count) -> void
 OpenTelemetry.Batch<T>.Count.get -> long
 OpenTelemetry.Batch<T>.Dispose() -> void
 OpenTelemetry.Batch<T>.Enumerator
-~OpenTelemetry.Batch<T>.Enumerator.Current.get -> T
+OpenTelemetry.Batch<T>.Enumerator.Current.get -> T!
 OpenTelemetry.Batch<T>.Enumerator.Dispose() -> void
 OpenTelemetry.Batch<T>.Enumerator.Enumerator() -> void
 OpenTelemetry.Batch<T>.Enumerator.MoveNext() -> bool
 OpenTelemetry.Batch<T>.Enumerator.Reset() -> void
 ~OpenTelemetry.Batch<T>.GetEnumerator() -> OpenTelemetry.Batch<T>.Enumerator
 OpenTelemetry.BatchActivityExportProcessor
 ~OpenTelemetry.BatchActivityExportProcessor.BatchActivityExportProcessor(OpenTelemetry.BaseExporter<System.Diagnostics.Activity> exporter, int maxQueueSize = 2048, int scheduledDelayMilliseconds = 5000, int exporterTimeoutMilliseconds = 30000, int maxExportBatchSize = 512) -> void
-~OpenTelemetry.BatchExportProcessor<T>
-~OpenTelemetry.BatchExportProcessor<T>.BatchExportProcessor(OpenTelemetry.BaseExporter<T> exporter, int maxQueueSize = 2048, int scheduledDelayMilliseconds = 5000, int exporterTimeoutMilliseconds = 30000, int maxExportBatchSize = 512) -> void
+OpenTelemetry.BatchExportProcessor<T>
+OpenTelemetry.BatchExportProcessor<T>.BatchExportProcessor(OpenTelemetry.BaseExporter<T!>! exporter, int maxQueueSize = 2048, int scheduledDelayMilliseconds = 5000, int exporterTimeoutMilliseconds = 30000, int maxExportBatchSize = 512) -> void
 ~OpenTelemetry.BatchExportProcessorOptions<T>
 OpenTelemetry.BatchExportProcessorOptions<T>.BatchExportProcessorOptions() -> void
 OpenTelemetry.BatchExportProcessorOptions<T>.ExporterTimeoutMilliseconds.get -> int
@@ -46,16 +46,16 @@ OpenTelemetry.BatchExportProcessorOptions<T>.ScheduledDelayMilliseconds.set -> v
 OpenTelemetry.BatchLogRecordExportProcessor
 OpenTelemetry.BatchLogRecordExportProcessor.BatchLogRecordExportProcessor(OpenTelemetry.BaseExporter<OpenTelemetry.Logs.LogRecord!>! exporter, int maxQueueSize = 2048, int scheduledDelayMilliseconds = 5000, int exporterTimeoutMilliseconds = 30000, int maxExportBatchSize = 512) -> void
 OpenTelemetry.CompositeProcessor<T>
-~OpenTelemetry.CompositeProcessor<T>.AddProcessor(OpenTelemetry.BaseProcessor<T> processor) -> OpenTelemetry.CompositeProcessor<T>
-~OpenTelemetry.CompositeProcessor<T>.CompositeProcessor(System.Collections.Generic.IEnumerable<OpenTelemetry.BaseProcessor<T>> processors) -> void
+OpenTelemetry.CompositeProcessor<T>.AddProcessor(OpenTelemetry.BaseProcessor<T>! processor) -> OpenTelemetry.CompositeProcessor<T>!
+OpenTelemetry.CompositeProcessor<T>.CompositeProcessor(System.Collections.Generic.IEnumerable<OpenTelemetry.BaseProcessor<T>!>! processors) -> void
 OpenTelemetry.ExportProcessorType
 OpenTelemetry.ExportProcessorType.Batch = 1 -> OpenTelemetry.ExportProcessorType
 OpenTelemetry.ExportProcessorType.Simple = 0 -> OpenTelemetry.ExportProcessorType
 OpenTelemetry.ExportResult
 OpenTelemetry.ExportResult.Failure = 1 -> OpenTelemetry.ExportResult
 OpenTelemetry.ExportResult.Success = 0 -> OpenTelemetry.ExportResult
 OpenTelemetry.Logs.LogRecord
-OpenTelemetry.Logs.LogRecord.CategoryName.get -> string!
+OpenTelemetry.Logs.LogRecord.CategoryName.get -> string?
 OpenTelemetry.Logs.LogRecord.EventId.get -> Microsoft.Extensions.Logging.EventId
 OpenTelemetry.Logs.LogRecord.Exception.get -> System.Exception?
 OpenTelemetry.Logs.LogRecord.ForEachScope<TState>(System.Action<OpenTelemetry.Logs.LogRecordScope, TState>! callback, TState state) -> void
@@ -216,8 +216,8 @@ OpenTelemetry.Resources.ResourceBuilderExtensions
 OpenTelemetry.Sdk
 OpenTelemetry.SimpleActivityExportProcessor
 ~OpenTelemetry.SimpleActivityExportProcessor.SimpleActivityExportProcessor(OpenTelemetry.BaseExporter<System.Diagnostics.Activity> exporter) -> void
-~OpenTelemetry.SimpleExportProcessor<T>
-~OpenTelemetry.SimpleExportProcessor<T>.SimpleExportProcessor(OpenTelemetry.BaseExporter<T> exporter) -> void
+OpenTelemetry.SimpleExportProcessor<T>
+OpenTelemetry.SimpleExportProcessor<T>.SimpleExportProcessor(OpenTelemetry.BaseExporter<T!>! exporter) -> void
 OpenTelemetry.SimpleLogRecordExportProcessor
 OpenTelemetry.SimpleLogRecordExportProcessor.SimpleLogRecordExportProcessor(OpenTelemetry.BaseExporter<OpenTelemetry.Logs.LogRecord!>! exporter) -> void
 OpenTelemetry.SuppressInstrumentationScope
@@ -270,7 +270,7 @@ override OpenTelemetry.BaseExportProcessor<T>.OnForceFlush(int timeoutMillisecon
 override OpenTelemetry.BaseExportProcessor<T>.OnShutdown(int timeoutMilliseconds) -> bool
 ~override OpenTelemetry.BatchActivityExportProcessor.OnEnd(System.Diagnostics.Activity data) -> void
 override OpenTelemetry.BatchExportProcessor<T>.Dispose(bool disposing) -> void
-~override OpenTelemetry.BatchExportProcessor<T>.OnExport(T data) -> void
+override OpenTelemetry.BatchExportProcessor<T>.OnExport(T! data) -> void
 override OpenTelemetry.BatchExportProcessor<T>.OnForceFlush(int timeoutMilliseconds) -> bool
 override OpenTelemetry.BatchExportProcessor<T>.OnShutdown(int timeoutMilliseconds) -> bool
 override OpenTelemetry.BatchLogRecordExportProcessor.OnEnd(OpenTelemetry.Logs.LogRecord! data) -> void
@@ -288,7 +288,7 @@ override OpenTelemetry.Metrics.BaseExportingMetricReader.OnShutdown(int timeoutM
 override OpenTelemetry.Metrics.PeriodicExportingMetricReader.Dispose(bool disposing) -> void
 override OpenTelemetry.Metrics.PeriodicExportingMetricReader.OnShutdown(int timeoutMilliseconds) -> bool
 ~override OpenTelemetry.SimpleActivityExportProcessor.OnEnd(System.Diagnostics.Activity data) -> void
-~override OpenTelemetry.SimpleExportProcessor<T>.OnExport(T data) -> void
+override OpenTelemetry.SimpleExportProcessor<T>.OnExport(T! data) -> void
 override OpenTelemetry.Trace.AlwaysOffSampler.ShouldSample(in OpenTelemetry.Trace.SamplingParameters samplingParameters) -> OpenTelemetry.Trace.SamplingResult
 override OpenTelemetry.Trace.AlwaysOnSampler.ShouldSample(in OpenTelemetry.Trace.SamplingParameters samplingParameters) -> OpenTelemetry.Trace.SamplingResult
 override OpenTelemetry.Trace.ParentBasedSampler.ShouldSample(in OpenTelemetry.Trace.SamplingParameters samplingParameters) -> OpenTelemetry.Trace.SamplingResult