[Instrumentation.Wcf] Allow WCF services to record exceptions if RecordException is set

src/OpenTelemetry.Instrumentation.Wcf/CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## Unreleased
 
+* Added server instrumentation support for `RecordException` option.
+  ([#2880](https://github.com/open-telemetry/opentelemetry-dotnet-contrib/pull/2880))
+
 ## 1.12.0-beta.1
 
 Released 2025-May-06

src/OpenTelemetry.Instrumentation.Wcf/Implementation/TelemetryDispatchMessageInspector.cs

@@ -104,6 +104,11 @@ internal TelemetryDispatchMessageInspector(IDictionary<string, ActionMetadata> a
                 }
             }
 
+            if (WcfInstrumentationActivitySource.Options.RecordException)
+            {
+                OperationContext.Current?.Extensions.Add(new WcfOperationContext(activity));
+            }
+
             if (textMapPropagator is not TraceContextPropagator)
             {
                 Baggage.Current = ctx.Baggage;

src/OpenTelemetry.Instrumentation.Wcf/Implementation/TracingErrorHandler.cs

@@ -0,0 +1,48 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#if NETFRAMEWORK
+using System.Diagnostics;
+using System.ServiceModel;
+using System.ServiceModel.Channels;
+using System.ServiceModel.Dispatcher;
+
+namespace OpenTelemetry.Instrumentation.Wcf.Implementation;
+
+internal class TracingErrorHandler : IErrorHandler
+{
+    public bool HandleError(Exception error)
+    {
+        return false;
+    }
+
+    public void ProvideFault(Exception error, MessageVersion version, ref Message fault)
+    {
+        // By rights this should be in `HandleError` instead, which would keep it from
+        // interfering with the response to the client.
+        // However, by the time `HandleError` fires, the Activity has already been stopped
+        // so the error appears after the Activity has completed.  Additionally, sometimes
+        // the context has already been disposed or otherwise lost, preventing association
+        // at all.
+        // Also it becomes very difficult to unit-test, because there is no easy `ErrorsHandled`
+        // event to listen for before checking to see whether the error was logged.
+
+        if (!WcfInstrumentationActivitySource.Options?.RecordException ?? false)
+        {
+            return;
+        }
+
+        // OperationContext.Current *should* be reliable even in async calls at .NET 4.6.2+.
+        // In older versions it may not be.
+        var context = OperationContext.Current?.Extensions.Find<WcfOperationContext>();
+        var activity = context?.Activity ?? WcfInstrumentationActivitySource.ActivitySource.StartActivity(WcfInstrumentationActivitySource.UnassociatedExceptionActivityName, ActivityKind.Internal);
+
+        activity?.AddException(error);
+
+        if (activity != context?.Activity)
+        {
+            activity?.Stop();
+        }
+    }
+}
+#endif

src/OpenTelemetry.Instrumentation.Wcf/Implementation/WcfInstrumentationActivitySource.cs

@@ -19,6 +19,7 @@ internal static class WcfInstrumentationActivitySource
     internal static readonly string ActivitySourceName = AssemblyName.Name!;
     internal static readonly string IncomingRequestActivityName = ActivitySourceName + ".IncomingRequest";
     internal static readonly string OutgoingRequestActivityName = ActivitySourceName + ".OutgoingRequest";
+    internal static readonly string UnassociatedExceptionActivityName = ActivitySourceName + ".Exception";
 
     public static ActivitySource ActivitySource { get; } = new(ActivitySourceName, Assembly.GetPackageVersion());
 

src/OpenTelemetry.Instrumentation.Wcf/Implementation/WcfOperationContext.cs

@@ -0,0 +1,27 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#if NETFRAMEWORK
+using System.Diagnostics;
+using System.ServiceModel;
+
+namespace OpenTelemetry.Instrumentation.Wcf.Implementation;
+
+internal class WcfOperationContext : IExtension<OperationContext>
+{
+    public WcfOperationContext(Activity activity)
+    {
+        this.Activity = activity;
+    }
+
+    public Activity Activity { get; }
+
+    public void Attach(OperationContext owner)
+    {
+    }
+
+    public void Detach(OperationContext owner)
+    {
+    }
+}
+#endif

src/OpenTelemetry.Instrumentation.Wcf/README.md

@@ -233,8 +233,8 @@ This instrumentation can be configured to change the default behavior by using
 
 This instrumentation automatically sets Activity Status to Error if an unhandled
 exception is thrown. Additionally, `RecordException` feature may be turned on,
-to store the exception to the Activity itself as ActivityEvent. `RecordException`
-is available only on the client side.
+to store the exception to the Activity itself as ActivityEvent. This feature
+applies both on instrumented servers and clients.
 
 ## References
 

src/OpenTelemetry.Instrumentation.Wcf/TelemetryContractBehaviorAttribute.cs

@@ -45,6 +45,7 @@ public void ApplyDispatchBehavior(ContractDescription contractDescription, Servi
     {
 #if NETFRAMEWORK
         Guard.ThrowIfNull(dispatchRuntime);
+        dispatchRuntime.ChannelDispatcher.ErrorHandlers.Add(new TracingErrorHandler());
         TelemetryEndpointBehavior.ApplyDispatchBehaviorToEndpoint(dispatchRuntime.EndpointDispatcher);
 #endif
     }

src/OpenTelemetry.Instrumentation.Wcf/TelemetryEndpointBehavior.cs

@@ -41,6 +41,7 @@ public void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher e
     {
 #if NETFRAMEWORK
         Guard.ThrowIfNull(endpointDispatcher);
+        endpointDispatcher.ChannelDispatcher.ErrorHandlers.Add(new TracingErrorHandler());
         ApplyDispatchBehaviorToEndpoint(endpointDispatcher);
 #endif
     }

src/OpenTelemetry.Instrumentation.Wcf/TelemetryServiceBehavior.cs

@@ -5,6 +5,7 @@
 using System.ServiceModel;
 using System.ServiceModel.Description;
 using System.ServiceModel.Dispatcher;
+using OpenTelemetry.Instrumentation.Wcf.Implementation;
 using OpenTelemetry.Internal;
 
 namespace OpenTelemetry.Instrumentation.Wcf;
@@ -27,6 +28,9 @@ public void ApplyDispatchBehavior(ServiceDescription serviceDescription, Service
         foreach (var channelDispatcherBase in serviceHostBase.ChannelDispatchers)
         {
             var channelDispatcher = (ChannelDispatcher)channelDispatcherBase;
+
+            channelDispatcher.ErrorHandlers.Add(new TracingErrorHandler());
+
             foreach (var endpointDispatcher in channelDispatcher.Endpoints)
             {
                 TelemetryEndpointBehavior.ApplyDispatchBehaviorToEndpoint(endpointDispatcher);

test/OpenTelemetry.Instrumentation.Wcf.Tests/TelemetryDispatchMessageInspectorTests.netfx.cs

@@ -205,6 +205,114 @@ await client.ExecuteAsync(
             Assert.Empty(stoppedActivities);
         }
     }
+
+    [Theory]
+    [InlineData(true, true, true)]
+    [InlineData(true, true, false)]
+    [InlineData(true, false, true)]
+    [InlineData(false, true, true)]
+    [InlineData(true, false, false)]
+    [InlineData(false, false, true)]
+    [InlineData(false, true, false)]
+    [InlineData(false, false, false)]
+    public async Task RecordExceptionTest(
+        bool recordException,
+        bool triggerException,
+        bool runAsync)
+    {
+        List<Activity> stoppedActivities = [];
+        List<Activity> startedActivities = [];
+
+        List<Exception> recordedExceptions = [];
+        using var activityListener = new ActivityListener
+        {
+            ShouldListenTo = activitySource => true,
+            ActivityStarted = startedActivities.Add,
+            ActivityStopped = stoppedActivities.Add,
+        };
+
+        activityListener.ExceptionRecorder += (Activity activity, Exception ex, ref TagList tags) =>
+        {
+            recordedExceptions.Add(ex);
+        };
+
+        ActivitySource.AddActivityListener(activityListener);
+
+        var tracerProvider = Sdk.CreateTracerProviderBuilder()
+            .AddWcfInstrumentation(options =>
+            {
+                options.RecordException = recordException;
+            })
+            .Build();
+
+        var client = new ServiceClient(
+            new NetTcpBinding(),
+            new EndpointAddress(new Uri(this.serviceBaseUri, "/Service")));
+        try
+        {
+            if (triggerException)
+            {
+                if (runAsync)
+                {
+                    await client.ErrorAsync();
+                }
+                else
+                {
+                    client.ErrorSynchronous();
+                }
+            }
+            else
+            {
+                if (runAsync)
+                {
+                    await client.ExecuteAsync(
+                        new ServiceRequest(
+                            payload: "Hello Open Telemetry!"));
+                }
+                else
+                {
+                    client.ExecuteSynchronous(
+                        new ServiceRequest(
+                            payload: "Hello Open Telemetry!"));
+                }
+            }
+        }
+        catch (Exception)
+        {
+        }
+        finally
+        {
+            startedActivities[0].AddTag(nameof(recordException), recordException);
+            startedActivities[0].AddTag(nameof(triggerException), triggerException);
+            startedActivities[0].AddTag(nameof(runAsync), runAsync);
+
+            if (client.State == CommunicationState.Faulted)
+            {
+                client.Abort();
+            }
+            else
+            {
+                client.Close();
+            }
+
+            tracerProvider?.Shutdown();
+            tracerProvider?.Dispose();
+
+            WcfInstrumentationActivitySource.Options = null;
+        }
+
+        Assert.NotEmpty(stoppedActivities);
+        var activity = Assert.Single(stoppedActivities);
+
+        if (recordException && triggerException)
+        {
+            Assert.Collection(recordedExceptions, e => Assert.IsType<Exception>(e));
+        }
+        else
+        {
+            Assert.Empty(recordedExceptions);
+        }
+    }
 }
 
 #endif