Merge from main.

OpenTelemetry.sln

@@ -233,13 +233,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "OpenTelemetry.Extensions.Se
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "OpenTelemetry.Extensions.Tracing", "src\OpenTelemetry.Extensions.Tracing\OpenTelemetry.Extensions.Tracing.csproj", "{F1C65913-81EC-4297-A666-A66280E3E1B6}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Examples.LogEmitter", "examples\LogEmitter\Examples.LogEmitter.csproj", "{CCBBAD69-4A7D-41F8-8697-6E3F043F7BD5}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Examples.LoggingExtensions", "examples\LoggingExtensions\Examples.LoggingExtensions.csproj", "{F5EFF065-7AF5-4D7D-8038-CC419ABD8777}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "OpenTelemetry.Extensions.Serilog", "src\OpenTelemetry.Extensions.Serilog\OpenTelemetry.Extensions.Serilog.csproj", "{0D85558E-15B9-4251-BDBD-9CB7933B57E2}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "OpenTelemetry.Extensions.Serilog.Tests", "test\OpenTelemetry.Extensions.Serilog.Tests\OpenTelemetry.Extensions.Serilog.Tests.csproj", "{6A2C122A-C1CD-4B6B-AE09-2ABB7D3C50CE}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Examples.LoggingExtensions", "examples\LoggingExtensions\Examples.LoggingExtensions.csproj", "{CCBBAD69-4A7D-41F8-8697-6E3F043F7BD5}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution

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

@@ -1,3 +1,3 @@
 #nullable enable
 Serilog.OpenTelemetrySerilogExtensions
-static Serilog.OpenTelemetrySerilogExtensions.OpenTelemetry(this Serilog.Configuration.LoggerSinkConfiguration! loggerConfiguration, OpenTelemetry.Logs.OpenTelemetryLoggerProvider! openTelemetryLoggerProvider) -> Serilog.LoggerConfiguration!
+static Serilog.OpenTelemetrySerilogExtensions.OpenTelemetry(this Serilog.Configuration.LoggerSinkConfiguration! loggerConfiguration, OpenTelemetry.Logs.OpenTelemetryLoggerProvider! openTelemetryLoggerProvider, bool disposeProvider = true) -> Serilog.LoggerConfiguration!

src/OpenTelemetry.Extensions.Serilog/OpenTelemetry.Extensions.Serilog.csproj

@@ -3,6 +3,7 @@
     <!-- OmniSharp/VS Code requires TargetFrameworks to be in descending order for IntelliSense and analysis. -->
     <TargetFrameworks>netstandard2.0</TargetFrameworks>
     <Description>Extensions to enable OpenTelemetry logging when using the Serilog library</Description>
+    <PackageTags>$(PackageTags);serilog;logging</PackageTags>
     <Nullable>enable</Nullable>
     <AnalysisMode>AllEnabledByDefault</AnalysisMode>
     <AnalysisLevel>latest</AnalysisLevel>
@@ -17,7 +18,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Serilog" Version="2.8.0" />
+    <PackageReference Include="Serilog" Version="$(SerilogPkgVer)" />
   </ItemGroup>
 
 </Project>

src/OpenTelemetry.Extensions.Serilog/OpenTelemetrySerilogExtensions.cs

@@ -29,17 +29,26 @@ public static class OpenTelemetrySerilogExtensions
         /// Adds a sink to Serilog <see cref="LoggerConfiguration"/> which will
         /// write to OpenTelemetry.
         /// </summary>
-        /// <param name="loggerConfiguration"><see cref="LoggerSinkConfiguration"/>.</param>
-        /// <param name="openTelemetryLoggerProvider"><see cref="OpenTelemetryLoggerProvider"/>.</param>
+        /// <param name="loggerConfiguration"><see
+        /// cref="LoggerSinkConfiguration"/>.</param>
+        /// <param name="openTelemetryLoggerProvider"><see
+        /// cref="OpenTelemetryLoggerProvider"/>.</param>
+        /// <param name="disposeProvider">Controls whether or not the supplied
+        /// <paramref name="openTelemetryLoggerProvider"/> will be disposed when
+        /// the logger is disposed. Default value: <see
+        /// langword="true"/>.</param>
         /// <returns>Supplied <see cref="LoggerConfiguration"/> for chaining calls.</returns>
         public static LoggerConfiguration OpenTelemetry(
             this LoggerSinkConfiguration loggerConfiguration,
-            OpenTelemetryLoggerProvider openTelemetryLoggerProvider)
+            OpenTelemetryLoggerProvider openTelemetryLoggerProvider,
+            bool disposeProvider = true)
         {
             Guard.ThrowIfNull(loggerConfiguration);
             Guard.ThrowIfNull(openTelemetryLoggerProvider);
 
-            return loggerConfiguration.Sink(new OpenTelemetrySerilogSink(openTelemetryLoggerProvider));
+#pragma warning disable CA2000 // Dispose objects before losing scope
+            return loggerConfiguration.Sink(new OpenTelemetrySerilogSink(openTelemetryLoggerProvider, disposeProvider));
+#pragma warning restore CA2000 // Dispose objects before losing scope
         }
     }
 }

src/OpenTelemetry.Extensions.Serilog/OpenTelemetrySerilogSink.cs

@@ -14,6 +14,7 @@
 // limitations under the License.
 // </copyright>
 
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using Microsoft.Extensions.Logging;
@@ -22,15 +23,32 @@
 
 namespace OpenTelemetry.Logs
 {
-    internal sealed class OpenTelemetrySerilogSink : ILogEventSink
+    internal sealed class OpenTelemetrySerilogSink : ILogEventSink, IDisposable
     {
+        private readonly OpenTelemetryLoggerProvider openTelemetryLoggerProvider;
         private readonly bool includeFormattedMessage;
         private readonly LogEmitter logEmitter;
+        private readonly bool disposeProvider;
 
-        public OpenTelemetrySerilogSink(OpenTelemetryLoggerProvider openTelemetryLoggerProvider)
+        public OpenTelemetrySerilogSink(OpenTelemetryLoggerProvider openTelemetryLoggerProvider, bool disposeProvider)
         {
-            this.includeFormattedMessage = openTelemetryLoggerProvider.IncludeFormattedMessage;
-            this.logEmitter = openTelemetryLoggerProvider.CreateEmitter();
+            Debug.Assert(openTelemetryLoggerProvider != null, "openTelemetryLoggerProvider was null");
+
+            this.openTelemetryLoggerProvider = openTelemetryLoggerProvider!;
+            this.disposeProvider = disposeProvider;
+
+            var logEmitter = this.openTelemetryLoggerProvider.CreateEmitter();
+            Debug.Assert(logEmitter != null, "logEmitter was null");
+
+            this.logEmitter = logEmitter!;
+
+            // TODO: This project can only access IncludeFormattedMessage
+            // because it can see SDK internals. At some point this is likely
+            // not to be the case. Need to figure out where to put
+            // IncludeFormattedMessage so that extensions can see it. Ideas:
+            // Make it public on OpenTelemetryLoggerProvider or expose it on
+            // LogEmitter instance.
+            this.includeFormattedMessage = this.openTelemetryLoggerProvider.IncludeFormattedMessage;
         }
 
         public void Emit(LogEvent logEvent)
@@ -62,23 +80,56 @@ public void Emit(LogEvent logEvent)
                 else if (property.Value is SequenceValue sequenceValue)
                 {
                     IReadOnlyList<LogEventPropertyValue> elements = sequenceValue.Elements;
-                    if (elements.Count > 0 && elements[0] is ScalarValue)
+                    if (elements.Count > 0)
                     {
-                        object[] values = new object[elements.Count];
+                        // Note: The goal here is to build a typed array (eg
+                        // int[]) if all the element types match otherwise
+                        // fallback to object[]
+
+                        Type? elementType = null;
+                        Array? values = null;
+
                         for (int i = 0; i < elements.Count; i++)
                         {
                             if (elements[i] is ScalarValue value)
                             {
-                                values[i] = value.Value;
+                                Type currentElementType = value.Value?.GetType() ?? typeof(object);
+
+                                if (values == null)
+                                {
+                                    elementType = currentElementType;
+                                    values = Array.CreateInstance(elementType, elements.Count);
+                                }
+                                else if (!elementType!.IsAssignableFrom(currentElementType))
+                                {
+                                    // Array with mixed types detected
+                                    object[] newValues = new object[elements.Count];
+                                    values.CopyTo(newValues, 0);
+                                    values = newValues;
+                                    elementType = typeof(object);
+                                }
+
+                                values.SetValue(value.Value, i);
                             }
                         }
 
-                        attributes.Add(property.Key, values);
+                        if (values != null)
+                        {
+                            attributes.Add(property.Key, values);
+                        }
                     }
                 }
             }
 
-            this.logEmitter.Log(in data, in attributes);
+            this.logEmitter.Emit(in data, in attributes);
+        }
+
+        public void Dispose()
+        {
+            if (this.disposeProvider)
+            {
+                this.openTelemetryLoggerProvider.Dispose();
+            }
         }
     }
 }

src/OpenTelemetry.Extensions.Serilog/README.md

@@ -1,26 +1,36 @@
 # OpenTelemetry.Extensions.Serilog
 
+[![NuGet](https://img.shields.io/nuget/v/OpenTelemetry.Extensions.Serilog.svg)](https://www.nuget.org/packages/OpenTelemetry.Extensions.Serilog)
+[![NuGet](https://img.shields.io/nuget/dt/OpenTelemetry.Extensions.Serilog.svg)](https://www.nuget.org/packages/OpenTelemetry.Extensions.Serilog)
+
 This project contains a [Serilog](https://github.com/serilog/)
 [sink](https://github.com/serilog/serilog/wiki/Configuration-Basics#sinks) for
 writing log messages to OpenTelemetry.
 
+## Installation
+
+```shell
+dotnet add package OpenTelemetry.Extensions.Serilog
+```
+
 ## Usage Example
 
 ```csharp
 // Step 1: Configure OpenTelemetryLoggerProvider...
-var resourceBuilder = ResourceBuilder.CreateDefault().AddService("MyService");
-
-using var openTelemetryLoggerProvider = new OpenTelemetryLoggerProvider(options =>
+var openTelemetryLoggerProvider = new OpenTelemetryLoggerProvider(options =>
 {
     options
-        .SetResourceBuilder(resourceBuilder)
+        .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService("MyService"))
         .AddConsoleExporter();
 });
 
 // Step 2: Register OpenTelemetry sink with Serilog...
 Log.Logger = new LoggerConfiguration()
-    .WriteTo.OpenTelemetry(openTelemetryLoggerProvider)
+    .WriteTo.OpenTelemetry(openTelemetryLoggerProvider, disposeProvider: true)
     .CreateLogger();
+
+// Step 3: When application is shutdown flush all log messages and dispose provider...
+Log.CloseAndFlush();
 ```
 
 ## References