Aspect-Injector driven Exception Logging and Asynchronous Code

[TheMouster]

Hi,

I’ve grabbed and modernised the code from issue 77 to make it compatible with the lastest incarnation of Aspect-Injector, but any attempts I make to acquire and log the exception fail with further exceptions, usually within the Aspect itself where elements are incompatible with the output required.

Does anyone using this extremely useful library have any ideas beyond what is mentioned in issue 77? I know the design of Aspect-Injector has moved a long way since issue 77, but the handling of async items seems to be either ignored or not discussed much.

Any help would be greatfully received.

Current code below, along with detail from a captured exception.

namespace CAS.FMS.AOP
{
    using AspectInjector.Broker;

    using Serilog;

    using System;
    using System.Reflection;
    using System.Threading.Tasks;

    [Aspect(Scope.Global)]
    [Injection(typeof(UniversalExceptionLoggingAspectAttribute))]
    public sealed class UniversalExceptionLoggingAspectAttribute : Attribute
    {
        private static MethodInfo _asyncErrorHandler = typeof(UniversalExceptionLoggingAspectAttribute).GetMethod(nameof(UniversalExceptionLoggingAspectAttribute.WrapAsync), BindingFlags.NonPublic | BindingFlags.Static);

        private static MethodInfo _syncErrorHandler = typeof(UniversalExceptionLoggingAspectAttribute).GetMethod(nameof(UniversalExceptionLoggingAspectAttribute.WrapSync), BindingFlags.NonPublic | BindingFlags.Static);


        [Advice(Kind.Around, Targets = Target.Method)]
        public object LogException([Argument(Source.Target)] Func<object[], object> target,
                                   [Argument(Source.Arguments)] object[] arguments,
                                   [Argument(Source.ReturnType)] Type returnType)
        {
            if (typeof(Task).IsAssignableFrom(returnType))
            {
                var asyncResultType = returnType.IsConstructedGenericType ? returnType.GenericTypeArguments[0] : typeof(object);
                return _asyncErrorHandler.MakeGenericMethod(asyncResultType).Invoke(this, new object[] { target, arguments });
            }
            else
            {
                return _syncErrorHandler.MakeGenericMethod(returnType).Invoke(this, new object[] { target, arguments });
            }
        }


        /// <summary>
        /// Handles logging exceptions in synchronous AOP wrapped functions.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="target">The target.</param>
        /// <param name="args">The arguments.</param>
        /// <returns>T</returns>
        private static T WrapSync<T>(Func<object[], object> target, object[] args)
        {
            try
            {
                return (T)target(args);
            }
            catch (Exception ex)
            {
                LogException(target.GetType().Name, ex);
                return default(T);
            }
        }

        /// <summary>
        /// Handle asynchronous exceptions in AOP wrapped functions.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="target">The target.</param>
        /// <param name="args">The arguments.</param>
        /// <returns>Task of T</returns>
        private static async Task<T> WrapAsync<T>(Func<object[], object> target, object[] args)
        {
            try
            {
                //return await (Task<T>)target(args); //Original
                return await ((Task<T>)target(args)).ConfigureAwait(false); //Theoretically improved
            }
            catch (Exception ex)
            {
                LogException(target.GetType().Name, ex);
                return default(T);
            }
        }

        /// <summary>
        /// Logs the caught exception for the AOP wrapped element.
        /// </summary>
        /// <param name="typeName">Name of the type.</param>
        /// <param name="ex">The exception.</param>
        private static void LogException(string typeName, Exception ex) => Log.Error("{type} threw a {exception} exception with {exceptionMessage}", typeName, ex.GetType().Name, ex.Message);
    }
}

Logged output when using the “Universal” logger. A much simpler, non async compatible version works correctly but obviously only on synchronous functions.

2022-05-01 12:34:26.993 +08:00 [DBG] Method IndexModel.OnGetAsync started.
2022-05-01 12:34:26.994 +08:00 [DBG] Method IndexModel.GetBookingsAsync started.
2022-05-01 12:35:38.106 +08:00 [ERR] Func`2 threw a InvalidCastException exception with Unable to cast object of type 'AsyncStateMachineBox`1[System.Threading.Tasks.VoidTaskResult,CAS.FMS.WWW.Areas.FMS.Pages.Manifests.IndexModel+<OnGetAsync>d__13]' to type 'System.Threading.Tasks.Task`1[System.Object]'.. Full exception trace: Name: InvalidCastException
Message: Unable to cast object of type 'AsyncStateMachineBox`1[System.Threading.Tasks.VoidTaskResult,CAS.FMS.WWW.Areas.FMS.Pages.Manifests.IndexModel+<OnGetAsync>d__13]' to type 'System.Threading.Tasks.Task`1[System.Object]'.
Stack Trace:    at CAS.FMS.AOP.UniversalExceptionLoggingAspectAttribute.WrapAsync[T](Func`2 target, Object[] args) in C:\Users\Greg\Development\CAS.FMS\CAS.FMS.AOP\UniversalExceptionLoggingAspectAttribute.cs:line 71

2022-05-01 12:37:02.648 +08:00 [ERR] Func`2 threw a ObjectDisposedException exception with IDataContext is disposed, see https://github.com/linq2db/linq2db/wiki/Managing-data-connection
Object name: 'DataConnection'.. Full exception trace: Name: ObjectDisposedException
Message: IDataContext is disposed, see https://github.com/linq2db/linq2db/wiki/Managing-data-connection
Object name: 'DataConnection'.
Stack Trace:    at LinqToDB.Data.DataConnection.CheckAndThrowOnDisposed()
   at LinqToDB.Data.DataConnection.LinqToDB.IDataContext.GetQueryRunner(Query query, Int32 queryNumber, Expression expression, Object[] parameters, Object[] preambles)
   at LinqToDB.Linq.QueryRunner.ExecuteQuery[T](Query query, IDataContext dataContext, Mapper`1 mapper, Expression expression, Object[] ps, Object[] preambles, Int32 queryNumber)+MoveNext()
   at System.Collections.Generic.List`1..ctor(IEnumerable`1 collection)
   at System.Linq.Enumerable.ToList[TSource](IEnumerable`1 source)
   at LinqToDB.Linq.Builder.EagerLoading.<>c__DisplayClass43_0`2.<RegisterPreambles>b__0(IDataContext dc, Expression expr, Object[] ps)
   at LinqToDB.Linq.Builder.ExpressionBuilder.<>c__DisplayClass212_0`1.<RegisterPreamble>b__0(IDataContext dc, Expression e, Object[] ps)
   at LinqToDB.Linq.Query.InitPreambles(IDataContext dc, Expression rootExpression, Object[] ps)
   at LinqToDB.Linq.ExpressionQuery`1.System.Collections.Generic.IEnumerable<T>.GetEnumerator()
   at LinqToDB.LinqExtensions.LoadWithQueryable`2.GetEnumerator()
   at System.Linq.Enumerable.TakeWhileIterator[TSource](IEnumerable`1 source, Func`2 predicate)+MoveNext()
   at System.Collections.Generic.List`1..ctor(IEnumerable`1 collection)
   at System.Linq.Enumerable.ToList[TSource](IEnumerable`1 source)
   at LinqToDB.AsyncExtensions.<>c__DisplayClass8_0`1.<ToListAsync>b__0()
   at System.Threading.Tasks.Task`1.InnerInvoke()
   at System.Threading.Tasks.Task.<>c.<.cctor>b__277_0(Object obj)
   at System.Threading.ExecutionContext.RunFromThreadPoolDispatchLoop(Thread threadPoolThread, ExecutionContext executionContext, ContextCallback callback, Object state)
--- End of stack trace from previous location ---
   at System.Threading.Tasks.Task.ExecuteWithThreadLocal(Task& currentTaskSlot, Thread threadPoolThread)
--- End of stack trace from previous location ---
   at LinqToDB.AsyncExtensions.ToListAsync[TSource](IQueryable`1 source, CancellationToken token)
   at CAS.FMS.WWW.Areas.FMS.Pages.Manifests.IndexModel.GetBookingsAsync() in C:\Users\Greg\Development\CAS.FMS\CAS.FMS.WWW\Areas\FMS\Pages\Manifests\Index.cshtml.cs:line 102
   at CAS.FMS.AOP.UniversalExceptionLoggingAspectAttribute.WrapAsync[T](Func`2 target, Object[] args) in C:\Users\Greg\Development\CAS.FMS\CAS.FMS.AOP\UniversalExceptionLoggingAspectAttribute.cs:line 71

2022-05-01 12:37:02.648 +08:00 [DBG] Method IndexModel.OnGetAsync completed.

[pamidur]

Hi @TheMouster , the development went as far as here https://github.com/pamidur/aspect-injector/blob/master/samples/src/Universal/Aspects/BaseUniversalWrapperAspect.cs
you can either copy it.

or use an attribute from Aspects.Universal package

aspect-injector/samples/src/Universal/Attributes/BaseMethodPointsAspectAttribute.cs

Line 51 in e84f13f

protected virtual T OnException<T>(AspectEventArgs eventArgs, Exception exception)

like this

[Injection(typeof(MethodWrapperAspect))]
class MyExceptionHandlingAttribute : Aspects.Universal.Attributes.BaseMethodPointsAspectAttribute
{
    protected override T OnException<T>(AspectEventArgs eventArgs, Exception exception)
    {
        Log.Error("{type} threw a {exception} exception with {exceptionMessage}", eventArgs.Type, exception.GetType().Name, exception.Message);
        return default(T);
    }
}

let me know if it works for you

[TheMouster]

Thank you so much. Vast improvement over my tacky hack, as in it actually works. Nice work. Cheers.

[emialmasia]

@pamidur @StefH @zhipu123

//this code, not catch all exepction
//Is there a way for the above code to work as AppDomain.CurrentDomain.FirstChanceException ?
//and catch all exception

//If the method has an internal try catch and the catch does not have a throw,
//then "protected override T OnException"
//will not catch exception

//this does it
//FirstChanceException
?????

//Can you understand what is happening?

//Is there any way to combine AspectInjection with
// AppDomain.CurrentDomain.FirstChanceException

//or do similar behavior
????

///example

[Injection(typeof(MethodWrapperAspect))]
class MyExceptionHandlingAttribute : Aspects.Universal.Attributes.BaseMethodPointsAspectAttribute
{
protected override T OnException(AspectEventArgs eventArgs, Exception exception)
{
Log.Error("{type} threw a {exception} exception with {exceptionMessage}", eventArgs.Type, exception.GetType().Name, exception.Message);
return default(T);
}
}

///////////////////// set at assembly scope
[assembly: MyExceptionHandling]

//////////////////////my class

public class MiClase
{

    public int Sumar(int a, int b)
    {
       try
       {

      
        try
        {

            throw new Exception("excTest1");
            return a + b;
        
        }
        catch (Exception e)
        {

                //throw;    //<--- comment throw ,  the exepction never catch of "protected override T OnException"
                return 1;
        }

       }
       catch (Exception)
       {

           throw;
       }

    }
}

////////////////main

var miClase = new MiClase();
int resultado = miClase.Sumar(5, 10);
Console.WriteLine($"Resultado: {resultado}");

/////////////////////////////////////////////////////////////////////////

//Is there a way for the above code to work as AppDomain.CurrentDomain.FirstChanceException

////example

//////////// in Main()

AppDomain.CurrentDomain.FirstChanceException += OnFirstChanceException;

///////definition of OnFirstChangeException /// this code catch exeption first of throw new Exception("excTest1");

private static void OnFirstChanceException(object sender, FirstChanceExceptionEventArgs args)
{
if (_insideFirstChanceExceptionHandler)
{
// Prevent recursion if an exception is thrown inside this method
return;
}

        _insideFirstChanceExceptionHandler = true;
        try
        {
         Log.Error("Something");
            // Code which may throw an exception
        }
        catch
        {
            // You have to catch all exceptions inside this method
        }
        finally
        {
            _insideFirstChanceExceptionHandler = false;
        }
    }