add support for standardError propagation

Author: mihainradu

src/UiPath.CoreIpc.Tests/Services/ISystemService.cs

@@ -47,6 +47,7 @@ public interface ISystemService
     Task<string> DanishNameOfDay(DayOfWeek day, CancellationToken ct);
 
     Task<byte[]> ReverseBytes(byte[] bytes, CancellationToken ct = default);
+    Task<bool> ThrowWithData(string serializedkey, object? serializedValue, string notSerializedKey);
 }
 
 public interface IUnregisteredCallback

src/UiPath.CoreIpc.Tests/Services/SystemService.cs

@@ -102,4 +102,13 @@ public Task<byte[]> ReverseBytes(byte[] bytes, CancellationToken ct = default)
         }
         return Task.FromResult(bytes);
     }
+
+    public async Task<bool> ThrowWithData(string serializedkey, object? serializedValue, string notSerializedKey)
+    {
+        var ex = new NotImplementedException();
+        ex.Data[serializedkey] = serializedValue;
+        ex.Data[notSerializedKey] = serializedValue;
+        await Task.Yield();
+        throw ex;
+    }
 }

src/UiPath.CoreIpc.Tests/SystemTests.cs

@@ -142,6 +142,32 @@ public async Task ServerCallingInexistentCallback_ShouldThrow()
         marshalledExceptionType.ShouldBe(typeof(EndpointNotFoundException).FullName);
     }
 
+    [Theory]
+    [InlineData("someString")]
+    [InlineData(2)]
+    [InlineData(false)]
+    [InlineData(null)]
+    public async Task ExceptionDataIsMarshalled(object? value)
+    {
+        const string notSerialized = "notSerializedKey";
+        const string Serializedkey = "somekey";
+        const string ExtraSerializbleKey = "extraData";
+        Error.SerializableDataKeys.Add(Serializedkey);
+        Error.SerializableDataKeys.Add(ExtraSerializbleKey);
+
+        _onError = (callInfo, ex) =>
+        {
+            ex.Data.Add(ExtraSerializbleKey, value);
+            return ex;
+        };
+
+
+        var ex = await Proxy.ThrowWithData(Serializedkey, value, notSerialized).ShouldThrowAsync<RemoteException>();
+        ex.Data[Serializedkey].ShouldBe(value);
+        ex.Data.Contains(notSerialized).ShouldBeFalse();
+        ex.Data[ExtraSerializbleKey].ShouldBe(value);
+    }
+
     [Fact]
     public async Task ServerCallingInexistentCallback_ShouldThrow2()
     => await Proxy.AddIncrement(1, 2).ShouldThrowAsync<RemoteException>()

src/UiPath.CoreIpc.Tests/TestBase.cs

@@ -24,6 +24,7 @@ public abstract class TestBase : IAsyncLifetime
 
     protected readonly ConcurrentBag<CallInfo> _serverBeforeCalls = new();
     protected BeforeCallHandler? _tailBeforeCall = null;
+    protected Func<CallInfo?, Exception, Exception> _onError;
 
     public TestBase(ITestOutputHelper outputHelper)
     {
@@ -91,7 +92,8 @@ async Task<IpcServer> Core()
                 {
                     _serverBeforeCalls.Add(callInfo);
                     return _tailBeforeCall?.Invoke(callInfo, ct) ?? Task.CompletedTask;
-                }
+                },
+                OnError = (callInfo, exception) => _onError?.Invoke(callInfo, exception)
             };
 
             return new()

src/UiPath.CoreIpc/Helpers/Helpers.cs

@@ -13,8 +13,7 @@ namespace UiPath.Ipc;
 internal static class Helpers
 {
     internal const BindingFlags InstanceFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly;
-    internal static Error ToError(this Exception ex) => new(ex.Message, ex.StackTrace ?? ex.GetBaseException().StackTrace!, GetExceptionType(ex), ex.InnerException?.ToError());
-    private static string GetExceptionType(Exception exception) => (exception as RemoteException)?.Type ?? exception.GetType().FullName!;
+    internal static Error ToError(this Exception ex) => Error.FromException(ex);
     internal static bool Enabled(this ILogger? logger, LogLevel logLevel = LogLevel.Information) => logger is not null && logger.IsEnabled(logLevel);
     [Conditional("DEBUG")]
     internal static void AssertDisposed(this SemaphoreSlim semaphore) => semaphore.AssertFieldNull("m_waitHandle");

src/UiPath.CoreIpc/Helpers/Router.cs

@@ -134,11 +134,13 @@ public static Route From(IServiceProvider? serviceProvider, ContractSettings end
         BeforeCall = endpointSettings.BeforeIncomingCall,
         Scheduler = endpointSettings.Scheduler.OrDefault(),
         LoggerFactory = serviceProvider.MaybeCreateServiceFactory<ILoggerFactory>(),
+        OnError = endpointSettings.OnError,
     };
 
     public required ServiceFactory Service { get; init; }
 
     public TaskScheduler Scheduler { get; init; }
     public BeforeCallHandler? BeforeCall { get; init; }
     public Func<ILoggerFactory>? LoggerFactory { get; init; }
+    public Func<CallInfo?, Exception, Exception>? OnError { get; init; }
 }

src/UiPath.CoreIpc/Server/ContractSettings.cs

@@ -7,11 +7,13 @@ public sealed class ContractSettings
     public TaskScheduler? Scheduler { get; set; }
     public BeforeCallHandler? BeforeIncomingCall { get; set; }
     internal ServiceFactory Service { get; }
+    public Func<CallInfo?, Exception, Exception>? OnError { get; set; }
 
     internal Type ContractType => Service.Type;
     internal object? ServiceInstance => Service.MaybeGetInstance();
     internal IServiceProvider? ServiceProvider => Service.MaybeGetServiceProvider();
 
+
     public ContractSettings(Type contractType, object? serviceInstance = null) : this(
         serviceInstance is not null
             ? new ServiceFactory.Instance()
@@ -40,5 +42,6 @@ internal ContractSettings(ContractSettings other)
         Scheduler = other.Scheduler;
         BeforeIncomingCall = other.BeforeIncomingCall;
         Service = other.Service;
+        OnError = other.OnError;
     }
 }

src/UiPath.CoreIpc/Server/Server.cs

@@ -102,6 +102,7 @@ private async ValueTask OnRequestReceived(Request request)
             }
             catch (Exception ex) when (response is null)
             {
+                ex = route.OnError?.Invoke(null, ex) ?? ex;
                 await OnError(request, timeoutHelper.CheckTimeout(ex, request.MethodName));
             }
             finally

src/UiPath.CoreIpc/Wire/Dtos.cs

@@ -48,17 +48,35 @@ public TResult Deserialize<TResult>()
     }
 }
 
-public record Error(string Message, string StackTrace, string Type, Error? InnerError)
+public record Error(string Message, string StackTrace, string Type, Error? InnerError, IReadOnlyDictionary<string, string>? Data)
 {
+    public static readonly HashSet<string> SerializableDataKeys = ["UiPath.ErrorInfo.Error"];
+
     [return: NotNullIfNotNull("exception")]
     public static Error? FromException(Exception? exception)
-    => exception is null 
-        ? null 
+    => exception is null
+        ? null
         : new(
-            Message: exception.Message, 
-            StackTrace: exception.StackTrace ?? exception.GetBaseException().StackTrace!, 
-            Type: GetExceptionType(exception), 
-            InnerError: FromException(exception.InnerException));
+            Message: exception.Message,
+            StackTrace: exception.StackTrace ?? exception.GetBaseException().StackTrace!,
+            Type: GetExceptionType(exception),
+            InnerError: FromException(exception.InnerException),
+            Data: GetExceptionData(exception));
+
+    private static IReadOnlyDictionary<string, string>? GetExceptionData(Exception exception)
+    {
+        Dictionary<string, string>? data = null;
+        foreach (var key in SerializableDataKeys)
+        {
+            if (exception.Data.Contains(key))
+            {
+                data ??= [];
+                data[key] = IpcJsonSerializer.Instance.Serialize(exception.Data[key]);
+            }
+        }
+        return data;
+    }
+
     public override string ToString() => new RemoteException(this).ToString();
 
     private static string GetExceptionType(Exception exception) => (exception as RemoteException)?.Type ?? exception.GetType().FullName!;
@@ -70,6 +88,13 @@ public class RemoteException : Exception
     {
         Type = error.Type;
         StackTrace = error.StackTrace;
+        if (error.Data != null)
+        {
+            foreach (var key in error.Data)
+            {
+                Data[key.Key] = IpcJsonSerializer.Instance.Deserialize(key.Value, typeof(object));
+            }
+        }
     }
     public string Type { get; }
     public override string StackTrace { get; }