feat: add on ending span processor functionality

This change creates a new ExtendedBaseProcessor that allows users
to implement onEnding functionality to their processor, as per
the spec: https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/sdk.md#onending

Author: majanjua-amzn

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

@@ -25,3 +25,7 @@ OpenTelemetry.Metrics.MetricStreamConfiguration.ExemplarReservoirFactory.set ->
 [OTEL1000]static Microsoft.Extensions.Logging.OpenTelemetryLoggingExtensions.UseOpenTelemetry(this Microsoft.Extensions.Logging.ILoggingBuilder! builder, System.Action<OpenTelemetry.Logs.LoggerProviderBuilder!>? configureBuilder, System.Action<OpenTelemetry.Logs.OpenTelemetryLoggerOptions!>? configureOptions) -> Microsoft.Extensions.Logging.ILoggingBuilder!
 [OTEL1001]static OpenTelemetry.Sdk.CreateLoggerProviderBuilder() -> OpenTelemetry.Logs.LoggerProviderBuilder!
 [OTEL1004]virtual OpenTelemetry.Metrics.FixedSizeExemplarReservoir.OnCollected() -> void
+OpenTelemetry.ExtendedBaseProcessor<T>
+OpenTelemetry.ExtendedBaseProcessor<T>.ExtendedBaseProcessor() -> void
+virtual OpenTelemetry.ExtendedBaseProcessor<T>.OnEnding(T data) -> void
+override OpenTelemetry.CompositeProcessor<T>.OnEnding(T data) -> void

src/OpenTelemetry/CHANGELOG.md

@@ -15,6 +15,9 @@ Notes](../../RELEASENOTES.md).
 * Add support for .NET 10.0.
   ([#6307](https://github.com/open-telemetry/opentelemetry-dotnet/pull/6307))
 
+* feat: add on ending span processor functionality
+  ([#6617](https://github.com/open-telemetry/opentelemetry-dotnet/pull/6617))
+
 ## 1.13.1
 
 Released 2025-Oct-09

src/OpenTelemetry/CompositeProcessor.cs

@@ -10,7 +10,7 @@ namespace OpenTelemetry;
 /// Represents a chain of <see cref="BaseProcessor{T}"/>s.
 /// </summary>
 /// <typeparam name="T">The type of object to be processed.</typeparam>
-public class CompositeProcessor<T> : BaseProcessor<T>
+public class CompositeProcessor<T> : ExtendedBaseProcessor<T>
 {
     internal readonly DoublyLinkedListNode Head;
     private DoublyLinkedListNode tail;
@@ -69,6 +69,18 @@ public override void OnEnd(T data)
         }
     }
 
+    /// <inheritdoc/>
+    public override void OnEnding(T data)
+    {
+        for (var cur = this.Head; cur != null; cur = cur.Next)
+        {
+            if (typeof(ExtendedBaseProcessor<T>).IsAssignableFrom(cur.Value.GetType()))
+            {
+                ((ExtendedBaseProcessor<T>)cur.Value).OnEnding(data);
+            }
+        }
+    }
+
     /// <inheritdoc/>
     public override void OnStart(T data)
     {

src/OpenTelemetry/ExtendedBaseProcessor.cs

@@ -0,0 +1,28 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+namespace OpenTelemetry;
+
+/// <summary>
+/// Extended base processor base class.
+/// </summary>
+/// <typeparam name="T">The type of object to be processed.</typeparam>
+#pragma warning disable CA1012 // Abstract types should not have public constructors
+public abstract class ExtendedBaseProcessor<T> : BaseProcessor<T>
+#pragma warning restore CA1012 // Abstract types should not have public constructors
+{
+    /// <summary>
+    /// Called synchronously before a telemetry object ends.
+    /// </summary>
+    /// <param name="data">
+    /// The started telemetry object.
+    /// </param>
+    /// <remarks>
+    /// This function is called synchronously on the thread which ended
+    /// the telemetry object. This function should be thread-safe, and
+    /// should not block indefinitely or throw exceptions.
+    /// </remarks>
+    public virtual void OnEnding(T data)
+    {
+    }
+}

src/OpenTelemetry/Trace/TracerProviderSdk.cs

@@ -189,6 +189,11 @@ internal TracerProviderSdk(
 
                 if (SuppressInstrumentationScope.DecrementIfTriggered() == 0)
                 {
+                    if (typeof(ExtendedBaseProcessor<Activity>).IsAssignableFrom(this.processor?.GetType()))
+                    {
+                        (this.processor as ExtendedBaseProcessor<Activity>)?.OnEnding(activity);
+                    }
+
                     this.processor?.OnEnd(activity);
                 }
             };
@@ -224,6 +229,11 @@ internal TracerProviderSdk(
 
                 if (SuppressInstrumentationScope.DecrementIfTriggered() == 0)
                 {
+                    if (typeof(ExtendedBaseProcessor<Activity>).IsAssignableFrom(this.processor?.GetType()))
+                    {
+                        (this.processor as ExtendedBaseProcessor<Activity>)?.OnEnding(activity);
+                    }
+
                     this.processor?.OnEnd(activity);
                 }
             };

test/OpenTelemetry.Tests/Shared/TestActivityProcessor.cs

@@ -5,9 +5,10 @@
 
 namespace OpenTelemetry.Tests;
 
-internal sealed class TestActivityProcessor : BaseProcessor<Activity>
+internal sealed class TestActivityProcessor : ExtendedBaseProcessor<Activity>
 {
     public Action<Activity>? StartAction;
+    public Action<Activity>? EndingAction;
     public Action<Activity>? EndAction;
 
     public TestActivityProcessor()
@@ -20,6 +21,13 @@ public TestActivityProcessor(Action<Activity>? onStart, Action<Activity>? onEnd)
         this.EndAction = onEnd;
     }
 
+    public TestActivityProcessor(Action<Activity>? onStart, Action<Activity>? onEnding, Action<Activity>? onEnd)
+    {
+        this.StartAction = onStart;
+        this.EndingAction = onEnding;
+        this.EndAction = onEnd;
+    }
+
     public bool ShutdownCalled { get; private set; }
 
     public bool ForceFlushCalled { get; private set; }
@@ -31,6 +39,11 @@ public override void OnStart(Activity span)
         this.StartAction?.Invoke(span);
     }
 
+    public override void OnEnding(Activity span)
+    {
+        this.EndingAction?.Invoke(span);
+    }
+
     public override void OnEnd(Activity span)
     {
         this.EndAction?.Invoke(span);

test/OpenTelemetry.Tests/Trace/CompositeActivityProcessorTests.cs

@@ -26,34 +26,38 @@ public void CompositeActivityProcessor_CallsAllProcessorSequentially()
         var result = string.Empty;
 
         using var p1 = new TestActivityProcessor(
-            activity => { result += "1"; },
-            activity => { result += "3"; });
+            activity => { result += "start1"; },
+            activity => { result += "end1"; });
         using var p2 = new TestActivityProcessor(
-            activity => { result += "2"; },
-            activity => { result += "4"; });
+            activity => { result += "start2"; },
+            activity => { result += "ending2"; },
+            activity => { result += "end2"; });
 
         using var activity = new Activity("test");
 
         using (var processor = new CompositeProcessor<Activity>([p1, p2]))
         {
             processor.OnStart(activity);
+            processor.OnEnding(activity);
             processor.OnEnd(activity);
         }
 
-        Assert.Equal("1234", result);
+        Assert.Equal("start1start2ending2end1end2", result);
     }
 
     [Fact]
     public void CompositeActivityProcessor_ProcessorThrows()
     {
         using var p1 = new TestActivityProcessor(
             _ => throw new InvalidOperationException("Start exception"),
+            _ => throw new InvalidOperationException("Ending exception"),
             _ => throw new InvalidOperationException("End exception"));
 
         using var activity = new Activity("test");
 
         using var processor = new CompositeProcessor<Activity>([p1]);
         Assert.Throws<InvalidOperationException>(() => { processor.OnStart(activity); });
+        Assert.Throws<InvalidOperationException>(() => { processor.OnEnding(activity); });
         Assert.Throws<InvalidOperationException>(() => { processor.OnEnd(activity); });
     }