[AOT] Fix RuntimeContext warnings

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 = "User-defined RuntimeContextSlotFactory that relies on Reflection is not timmer safe.")]
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL3050:RequiresDynamicCode", Justification = "User-defined RuntimeContextSlotFactory that relies on Reflection is not AoT safe.")]
+        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("ReflectionRuntimeContextSlotFactory is trimmer unsafe.")]
+            [RequiresDynamicCode("ReflectionRuntimeContextSlotFactory requires the ability to generate new code 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/OpenTelemetry.Api.csproj

@@ -15,4 +15,10 @@
   <ItemGroup>
     <PackageReference Include="System.Diagnostics.DiagnosticSource" />
   </ItemGroup>
+
+  <ItemGroup>
+    <Compile Include="$(RepoRoot)\src\OpenTelemetry\Internal\Shims\RequiresDynamicCodeAttribute.cs" Link ="Includes\RequiresDynamicCodeAttribute.cs" />
+    <Compile Include="$(RepoRoot)\src\OpenTelemetry\Internal\Shims\RequiresUnreferencedCodeAttribute.cs" Link="Includes\RequiresUnreferencedCodeAttribute.cs" />
+    <Compile Include="$(RepoRoot)\src\OpenTelemetry\Internal\Shims\UnconditionalSuppressMessageAttribute.cs" Link ="Includes\UnconditionalSuppressMessageAttribute.cs" Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'" />
+  </ItemGroup>
 </Project>

src/OpenTelemetry/Internal/OpenTelemetrySdkEventSource.cs

@@ -15,6 +15,7 @@
 // </copyright>
 
 #nullable enable
+#pragma warning disable 0436
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics.Tracing;
@@ -370,3 +371,4 @@ protected override void OnEventWritten(EventWrittenEventArgs e)
 #endif
     }
 }
+#pragma warning restore 0436

src/OpenTelemetry/Internal/Shims/RequiresDynamicCodeAttribute.cs

@@ -0,0 +1,59 @@
+// <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
+
+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)]
+#if SYSTEM_PRIVATE_CORELIB
+    public
+#else
+    internal
+#endif
+    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; }
+    }
+}

src/OpenTelemetry/Internal/Shims/RequiresUnreferencedCodeAttribute.cs

@@ -0,0 +1,55 @@
+// <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
+
+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; }
+    }
+}

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());
         }
     }
 }