[AOT] Fix RuntimeContext warnings

docs/logs/correlation/README.md

@@ -18,8 +18,8 @@ corresponding `Activity`.
 
 The good news is that, in OpenTelemetry .NET SDK, there is no user action
 required to enable correlation. i.e the SDK automatically enables logs to
-`Activity` correlation, by populating the fields `TraceId`, `SpanId` and
-`TraceFlags` from the active activity (i.e `Activity.Current`), if
+`Activity` correlation, by populating the fields `TraceId`, `SpanId`,
+`TraceFlags`, `TraceState` from the active activity (i.e `Activity.Current`), if
 any.
 
 The example [Program.cs](./Program.cs) shows how to emit logs within the context

src/OpenTelemetry.Api/Context/RuntimeContext.cs

@@ -15,6 +15,7 @@
 // </copyright>
 
 using System.Collections.Concurrent;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using OpenTelemetry.Internal;
 
@@ -27,10 +28,66 @@ public static class RuntimeContext
     {
         private static readonly ConcurrentDictionary<string, object> Slots = new();
 
+        private static Type contextSlotType;
+
+        private static RuntimeContextSlotFactory runtimeContextSlotFactory;
+
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "The AsyncLocalRuntimeContextSlot type is handled without using Reflection.")]
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL3050:RequiresDynamicCode", Justification = "The AsyncLocalRuntimeContextSlot type is handled without using Reflection.")]
+        static RuntimeContext()
+        {
+            ContextSlotType = typeof(AsyncLocalRuntimeContextSlot<>);
+        }
+
         /// <summary>
         /// Gets or sets the actual context carrier implementation.
         /// </summary>
-        public static Type ContextSlotType { get; set; } = typeof(AsyncLocalRuntimeContextSlot<>);
+        public static Type ContextSlotType
+        {
+            get
+            {
+                return contextSlotType;
+            }
+
+            [RequiresUnreferencedCode("Setting a custom ContextSlotType requires using Reflection to initialize the context slot.")]
+            [RequiresDynamicCode("Setting a custom ContextSlotType requires using MakeGenericType to initialize the context slot. The native code for the generic type might not be available at runtime.")]
+            set
+            {
+                Guard.ThrowIfNull(value, nameof(value));
+                if (!value.IsGenericType || !value.IsGenericTypeDefinition || value.GetGenericArguments().Length != 1)
+                {
+                    throw new NotSupportedException($"Type '{value}' must be generic with a single generic type argument.");
+                }
+
+                if (value == typeof(AsyncLocalRuntimeContextSlot<>))
+                {
+                    runtimeContextSlotFactory = new RuntimeContextSlotFactory.AsyncLocalRuntimeContextSlotFactory();
+                }
+                else if (value == typeof(ThreadLocalRuntimeContextSlot<>))
+                {
+                    runtimeContextSlotFactory = new RuntimeContextSlotFactory.ThreadLocalRuntimeContextSlotFactory();
+                }
+#if NETFRAMEWORK
+                else if (value == typeof(RemotingRuntimeContextSlot<>))
+                {
+                    runtimeContextSlotFactory = new RuntimeContextSlotFactory.RemotingRuntimeContextSlotFactory();
+                }
+#endif
+                else
+                {
+#if NETSTANDARD2_1_OR_GREATER || NET6_OR_GREATER
+                    if (!RuntimeFeature.IsDynamicCodeSupported)
+                    {
+                        throw new NotSupportedException($"Custom RuntimeContextSlot type '{value}' cannot be used because dynamic code is not supported");
+                    }
+#endif
+
+                    runtimeContextSlotFactory = new RuntimeContextSlotFactory.ReflectionRuntimeContextSlotFactory(contextSlotType);
+                }
+
+                contextSlotType = value;
+            }
+        }
 
         /// <summary>
         /// Register a named context slot.
@@ -49,9 +106,8 @@ public static RuntimeContextSlot<T> RegisterSlot<T>(string slotName)
                     throw new InvalidOperationException($"Context slot already registered: '{slotName}'");
                 }
 
-                var type = ContextSlotType.MakeGenericType(typeof(T));
-                var ctor = type.GetConstructor(new Type[] { typeof(string) });
-                var slot = (RuntimeContextSlot<T>)ctor.Invoke(new object[] { slotName });
+                var slot = runtimeContextSlotFactory.Create<T>(slotName);
+
                 Slots[slotName] = slot;
                 return slot;
             }

src/OpenTelemetry.Api/Context/RuntimeContextSlotFactory.cs

@@ -0,0 +1,66 @@
+// <copyright file="RuntimeContextSlotFactory.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>
+
+#nullable enable
+
+using System.Diagnostics.CodeAnalysis;
+
+namespace OpenTelemetry.Context
+{
+    internal abstract class RuntimeContextSlotFactory
+    {
+        public abstract RuntimeContextSlot<T> Create<T>(string name);
+
+        public sealed class AsyncLocalRuntimeContextSlotFactory : RuntimeContextSlotFactory
+        {
+            public override RuntimeContextSlot<T> Create<T>(string name)
+                => new AsyncLocalRuntimeContextSlot<T>(name);
+        }
+
+#if NETFRAMEWORK
+        public sealed class RemotingRuntimeContextSlotFactory : RuntimeContextSlotFactory
+        {
+            public override RuntimeContextSlot<T> Create<T>(string name)
+                => new RemotingRuntimeContextSlot<T>(name);
+        }
+#endif
+
+        public sealed class ThreadLocalRuntimeContextSlotFactory : RuntimeContextSlotFactory
+        {
+            public override RuntimeContextSlot<T> Create<T>(string name)
+                => new ThreadLocalRuntimeContextSlot<T>(name);
+        }
+
+        [RequiresUnreferencedCode("ReflectionRuntimeContextSlotFactory is trimmer unsafe.")]
+        [RequiresDynamicCode("ReflectionRuntimeContextSlotFactory requires the ability to generate new code at runtime.")]
+        public sealed class ReflectionRuntimeContextSlotFactory : RuntimeContextSlotFactory
+        {
+            private readonly Type runtimeContextSlotType;
+
+            public ReflectionRuntimeContextSlotFactory(Type runtimeContextSlotType)
+            {
+                this.runtimeContextSlotType = runtimeContextSlotType;
+            }
+
+            public override RuntimeContextSlot<T> Create<T>(string name)
+            {
+                var type = this.runtimeContextSlotType.MakeGenericType(typeof(T));
+                var ctor = type.GetConstructor(new Type[] { typeof(string) })!;
+                return (RuntimeContextSlot<T>)ctor.Invoke(new object[] { name })!;
+            }
+        }
+    }
+}

src/OpenTelemetry.Api/Internal/Shims/RequiresDynamicCodeAttribute.cs

@@ -0,0 +1,55 @@
+// <copyright file="RequiresDynamicCodeAttribute.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>
+
+#nullable enable
+#if !NET7_0_OR_GREATER
+namespace System.Diagnostics.CodeAnalysis
+{
+    /// <summary>
+    /// Indicates that the specified method requires the ability to generate new code at runtime,
+    /// for example through <see cref="Reflection"/>.
+    /// </summary>
+    /// <remarks>
+    /// This allows tools to understand which methods are unsafe to call when compiling ahead of time.
+    /// </remarks>
+    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Class, Inherited = false)]
+    internal sealed class RequiresDynamicCodeAttribute : Attribute
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequiresDynamicCodeAttribute"/> class
+        /// with the specified message.
+        /// </summary>
+        /// <param name="message">
+        /// A message that contains information about the usage of dynamic code.
+        /// </param>
+        public RequiresDynamicCodeAttribute(string message)
+        {
+            this.Message = message;
+        }
+
+        /// <summary>
+        /// Gets a message that contains information about the usage of dynamic code.
+        /// </summary>
+        public string Message { get; }
+
+        /// <summary>
+        /// Gets or sets an optional URL that contains more information about the method,
+        /// why it requires dynamic code, and what options a consumer has to deal with it.
+        /// </summary>
+        public string? Url { get; set; }
+    }
+}
+#endif

src/OpenTelemetry.Api/Internal/Shims/RequiresUnreferencedCodeAttribute.cs

@@ -0,0 +1,56 @@
+// <copyright file="RequiresUnreferencedCodeAttribute.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>
+
+#nullable enable
+#if NETFRAMEWORK || NETSTANDARD2_0_OR_GREATER
+namespace System.Diagnostics.CodeAnalysis
+{
+    /// <summary>
+    /// Indicates that the specified method requires dynamic access to code that is not referenced
+    /// statically, for example through <see cref="Reflection"/>.
+    /// </summary>
+    /// <remarks>
+    /// This allows tools to understand which methods are unsafe to call when removing unreferenced
+    /// code from an application.
+    /// </remarks>
+    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Class, Inherited = false)]
+    internal sealed class RequiresUnreferencedCodeAttribute : Attribute
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequiresUnreferencedCodeAttribute"/> class
+        /// with the specified message.
+        /// </summary>
+        /// <param name="message">
+        /// A message that contains information about the usage of unreferenced code.
+        /// </param>
+        public RequiresUnreferencedCodeAttribute(string message)
+        {
+            this.Message = message;
+        }
+
+        /// <summary>
+        /// Gets a message that contains information about the usage of unreferenced code.
+        /// </summary>
+        public string Message { get; }
+
+        /// <summary>
+        /// Gets or sets an optional URL that contains more information about the method,
+        /// why it requires unreferenced code, and what options a consumer has to deal with it.
+        /// </summary>
+        public string? Url { get; set; }
+    }
+}
+#endif

src/OpenTelemetry/Internal/Shims/UnconditionalSuppressMessageAttribute.cs → src/OpenTelemetry.Api/Internal/Shims/UnconditionalSuppressMessageAttribute.cs

@@ -14,7 +14,7 @@
 // limitations under the License.
 // </copyright>
 #nullable enable
-
+#if NETFRAMEWORK || NETSTANDARD2_0_OR_GREATER
 namespace System.Diagnostics.CodeAnalysis
 {
     /// <summary>
@@ -97,3 +97,4 @@ public UnconditionalSuppressMessageAttribute(string category, string checkId)
         public string? Justification { get; set; }
     }
 }
+#endif

src/OpenTelemetry.Api/OpenTelemetry.Api.csproj

@@ -1,11 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <!-- OmniSharp/VS Code requires TargetFrameworks to be in descending order for IntelliSense and analysis. -->
-    <TargetFrameworks>netstandard2.0;net462</TargetFrameworks>
+    <TargetFrameworks>net6.0;netstandard2.0;net462</TargetFrameworks>
     <Description>OpenTelemetry .NET API</Description>
     <RootNamespace>OpenTelemetry</RootNamespace>
 
-    <NoWarn>$(NoWarn),CS0618</NoWarn>
+    <NoWarn>$(NoWarn),CS0618, RS0026</NoWarn>
     <MinVerTagPrefix>core-</MinVerTagPrefix>
 
     <!-- this is temporary. will remove in future PR. -->
@@ -15,4 +15,5 @@
   <ItemGroup>
     <PackageReference Include="System.Diagnostics.DiagnosticSource" />
   </ItemGroup>
+
 </Project>

src/OpenTelemetry.Exporter.Console/OpenTelemetry.Exporter.Console.csproj

@@ -31,7 +31,7 @@
     <Compile Include="$(RepoRoot)\src\OpenTelemetry.Api\Internal\ExceptionExtensions.cs" Link="Includes\ExceptionExtensions.cs" />
     <Compile Include="$(RepoRoot)\src\OpenTelemetry.Api\Internal\Guard.cs" Link="Includes\Guard.cs" />
     <Compile Include="$(RepoRoot)\src\OpenTelemetry.Api\Internal\SpanAttributeConstants.cs" Link="Includes\SpanAttributeConstants.cs" />
-    <Compile Include="$(RepoRoot)\src\OpenTelemetry\Internal\Shims\UnconditionalSuppressMessageAttribute.cs" Link="Includes\UnconditionalSuppressMessageAttribute.cs" Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'" />
+    <Compile Include="$(RepoRoot)\src\OpenTelemetry.Api\Internal\Shims\UnconditionalSuppressMessageAttribute.cs" Link="Includes\UnconditionalSuppressMessageAttribute.cs" Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'" />
   </ItemGroup>
 
 </Project>

src/OpenTelemetry.Exporter.Jaeger/OpenTelemetry.Exporter.Jaeger.csproj

@@ -29,9 +29,8 @@
     <Compile Include="$(RepoRoot)\src\OpenTelemetry\Internal\PeerServiceResolver.cs" Link="Includes\PeerServiceResolver.cs" />
     <Compile Include="$(RepoRoot)\src\OpenTelemetry\Internal\ResourceSemanticConventions.cs" Link="Includes\ResourceSemanticConventions.cs" />
     <Compile Include="$(RepoRoot)\src\OpenTelemetry\Internal\TagTransformer.cs" Link="Includes\TagTransformer.cs" />
-    <Compile Include="$(RepoRoot)\src\OpenTelemetry\Internal\Shims\UnconditionalSuppressMessageAttribute.cs" Link ="Includes\UnconditionalSuppressMessageAttribute.cs" Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'" />
+    <Compile Include="$(RepoRoot)\src\OpenTelemetry.Api\Internal\Shims\UnconditionalSuppressMessageAttribute.cs" Link ="Includes\UnconditionalSuppressMessageAttribute.cs" Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'" />
   </ItemGroup>
-
   <ItemGroup>
     <PackageReference Include="System.Threading.Tasks.Extensions" Condition="'$(TargetFramework)' != 'netstandard2.1'" />
     <PackageReference Include="System.Text.Encodings.Web" Condition="'$(TargetFramework)' != 'net6.0'" />

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OpenTelemetry.Exporter.OpenTelemetryProtocol.csproj

@@ -36,7 +36,7 @@
     <Compile Include="$(RepoRoot)\src\OpenTelemetry\Internal\ResourceSemanticConventions.cs" Link="Includes\ResourceSemanticConventions.cs" />
     <Compile Include="$(RepoRoot)\src\OpenTelemetry\Internal\TagTransformer.cs" Link="Includes\TagTransformer.cs" />
     <Compile Include="$(RepoRoot)\src\OpenTelemetry\Internal\TagAndValueTransformer.cs" Link="Includes\TagAndValueTransformer.cs" />
-    <Compile Include="$(RepoRoot)\src\OpenTelemetry\Internal\Shims\UnconditionalSuppressMessageAttribute.cs" Link ="Includes\UnconditionalSuppressMessageAttribute.cs" Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'" />
+    <Compile Include="$(RepoRoot)\src\OpenTelemetry.Api\Internal\Shims\UnconditionalSuppressMessageAttribute.cs" Link ="Includes\UnconditionalSuppressMessageAttribute.cs" Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'" />
   </ItemGroup>
 
   <ItemGroup>

src/OpenTelemetry.Exporter.Zipkin/OpenTelemetry.Exporter.Zipkin.csproj

@@ -24,7 +24,7 @@
     <Compile Include="$(RepoRoot)\src\OpenTelemetry\Internal\PeerServiceResolver.cs" Link="Includes\PeerServiceResolver.cs" />
     <Compile Include="$(RepoRoot)\src\OpenTelemetry\Internal\ResourceSemanticConventions.cs" Link="Includes\ResourceSemanticConventions.cs" />
     <Compile Include="$(RepoRoot)\src\OpenTelemetry\Internal\TagTransformer.cs" Link="Includes\TagTransformer.cs" />
-    <Compile Include="$(RepoRoot)\src\OpenTelemetry\Internal\Shims\UnconditionalSuppressMessageAttribute.cs" Link ="Includes\UnconditionalSuppressMessageAttribute.cs" Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'" />
+    <Compile Include="$(RepoRoot)\src\OpenTelemetry.Api\Internal\Shims\UnconditionalSuppressMessageAttribute.cs" Link ="Includes\UnconditionalSuppressMessageAttribute.cs" Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'" />
   </ItemGroup>
 
   <ItemGroup>

src/OpenTelemetry/Logs/LoggerProviderSdk.cs

@@ -17,6 +17,9 @@
 #nullable enable
 
 using System.Diagnostics;
+#if NETSTANDARD2_1_OR_GREATER || NET6_0_OR_GREATER
+using System.Diagnostics.CodeAnalysis;
+#endif
 using System.Text;
 using Microsoft.Extensions.DependencyInjection;
 using OpenTelemetry.Internal;
@@ -201,7 +204,12 @@ public bool ContainsBatchProcessor(BaseProcessor<LogRecord> processor)
     }
 
     /// <inheritdoc />
-    protected override bool TryCreateLogger(string? name, out Logger? logger)
+    protected override bool TryCreateLogger(
+        string? name,
+#if NETSTANDARD2_1_OR_GREATER || NET6_0_OR_GREATER
+        [NotNullWhen(true)]
+#endif
+        out Logger? logger)
     {
         logger = new LoggerSdk(this, name);
         return true;

src/OpenTelemetry/OpenTelemetry.csproj

@@ -21,8 +21,4 @@
     <ProjectReference Include="$(RepoRoot)\src\OpenTelemetry.Api.ProviderBuilderExtensions\OpenTelemetry.Api.ProviderBuilderExtensions.csproj" />
   </ItemGroup>
 
-  <ItemGroup>
-    <Compile Remove="Internal\Shims\UnconditionalSuppressMessageAttribute.cs" Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'" />
-  </ItemGroup>
-
 </Project>

test/OpenTelemetry.AotCompatibility.Tests/AotCompatibilityTests.cs

@@ -85,7 +85,7 @@ public void EnsureAotCompatibility()
             Assert.True(process.ExitCode == 0, "Publishing the AotCompatibility app failed. See test output for more details.");
 
             var warnings = expectedOutput.ToString().Split('\n', '\r').Where(line => line.Contains("warning IL"));
-            Assert.Equal(58, warnings.Count());
+            Assert.Equal(55, warnings.Count());
         }
     }
 }