[sdk] Provide better concurrency modes

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

@@ -1,3 +1,9 @@
+OpenTelemetry.ConcurrencyModes
+OpenTelemetry.ConcurrencyModes.Multithreaded = 2 -> OpenTelemetry.ConcurrencyModes
+OpenTelemetry.ConcurrencyModes.Reentrant = 1 -> OpenTelemetry.ConcurrencyModes
+OpenTelemetry.ConcurrencyModesAttribute
+OpenTelemetry.ConcurrencyModesAttribute.ConcurrencyModesAttribute(OpenTelemetry.ConcurrencyModes supported) -> void
+OpenTelemetry.ConcurrencyModesAttribute.Supported.get -> OpenTelemetry.ConcurrencyModes
 OpenTelemetry.Metrics.Exemplar
 OpenTelemetry.Metrics.Exemplar.DoubleValue.get -> double
 OpenTelemetry.Metrics.Exemplar.Exemplar() -> void

src/OpenTelemetry/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+* Exposed `ConcurrencyModes` as a public contract for extensions (e.g.
+  exporters) to better express their concurrency requirements.
+  ([#5643](https://github.com/open-telemetry/opentelemetry-dotnet/pull/5643))
+
 ## 1.9.0-alpha.1
 
 Released 2024-May-20

src/OpenTelemetry/ConcurrencyModes.cs

@@ -0,0 +1,36 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+namespace OpenTelemetry;
+
+/// <summary>
+/// Describes the concurrency mode of an OpenTelemetry extension.
+/// </summary>
+[Flags]
+public enum ConcurrencyModes : byte
+{
+    /*
+    0 0 0 0 0 0 0 0
+    | | | | | | | |
+    | | | | | | | +--- Reentrant
+    | | | | | | +----- Multithreaded
+    | | | | | +------- (reserved)
+    | | | | +--------- (reserved)
+    | | | +----------- (reserved)
+    | | +------------- (reserved)
+    | +--------------- (reserved)
+    +----------------- (reserved)
+    */
+
+    /// <summary>
+    /// Reentrant, the component can be invoked recursively without resulting
+    /// a deadlock or infinite loop.
+    /// </summary>
+    Reentrant = 0b1,
+
+    /// <summary>
+    /// Multithreaded, the component can be invoked concurrently across
+    /// multiple threads.
+    /// </summary>
+    Multithreaded = 0b10,
+}

src/OpenTelemetry/ConcurrencyModesAttribute.cs

@@ -0,0 +1,27 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+namespace OpenTelemetry;
+
+/// <summary>
+/// An attribute for declaring the supported <see cref="ConcurrencyModes"/> of an OpenTelemetry extension.
+/// </summary>
+[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = true)]
+public sealed class ConcurrencyModesAttribute : Attribute
+{
+    private readonly ConcurrencyModes supportedConcurrencyModes;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ConcurrencyModesAttribute"/> class.
+    /// </summary>
+    /// <param name="supported"><see cref="ConcurrencyModes"/>.</param>
+    public ConcurrencyModesAttribute(ConcurrencyModes supported)
+    {
+        this.supportedConcurrencyModes = supported;
+    }
+
+    /// <summary>
+    /// Gets the supported <see cref="ConcurrencyModes"/>.
+    /// </summary>
+    public ConcurrencyModes Supported => this.supportedConcurrencyModes;
+}

src/OpenTelemetry/SimpleExportProcessor.cs

@@ -1,6 +1,7 @@
 // Copyright The OpenTelemetry Authors
 // SPDX-License-Identifier: Apache-2.0
 
+using System.Runtime.CompilerServices;
 using OpenTelemetry.Internal;
 
 namespace OpenTelemetry;
@@ -12,7 +13,8 @@ namespace OpenTelemetry;
 public abstract class SimpleExportProcessor<T> : BaseExportProcessor<T>
     where T : class
 {
-    private readonly object syncObject = new();
+    private readonly object? syncObject;
+    private readonly ConcurrencyModes supportedConcurrencyModes;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="SimpleExportProcessor{T}"/> class.
@@ -21,21 +23,46 @@ public abstract class SimpleExportProcessor<T> : BaseExportProcessor<T>
     protected SimpleExportProcessor(BaseExporter<T> exporter)
         : base(exporter)
     {
+        var exporterType = exporter.GetType();
+        var attributes = exporterType.GetCustomAttributes(typeof(ConcurrencyModesAttribute), true);
+        if (attributes.Length > 0)
+        {
+            var attr = (ConcurrencyModesAttribute)attributes[attributes.Length - 1];
+            this.supportedConcurrencyModes = attr.Supported;
+        }
+
+        if (!this.supportedConcurrencyModes.HasFlag(ConcurrencyModes.Multithreaded))
+        {
+            this.syncObject = new object();
+        }
     }
 
     /// <inheritdoc />
     protected override void OnExport(T data)
     {
-        lock (this.syncObject)
+        if (this.syncObject is null)
         {
-            try
-            {
-                this.exporter.Export(new Batch<T>(data));
-            }
-            catch (Exception ex)
+            this.OnExportInternal(data);
+        }
+        else
+        {
+            lock (this.syncObject)
             {
-                OpenTelemetrySdkEventSource.Log.SpanProcessorException(nameof(this.OnExport), ex);
+                this.OnExportInternal(data);
             }
         }
     }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void OnExportInternal(T data)
+    {
+        try
+        {
+            this.exporter.Export(new Batch<T>(data));
+        }
+        catch (Exception ex)
+        {
+            OpenTelemetrySdkEventSource.Log.SpanProcessorException(nameof(this.OnExport), ex);
+        }
+    }
 }