具有Autofac和DynamicProxy2异常处理的AOP

Question

I'm trying to centrally manage Exception handling for a certain method but I can't seem to get there.

public class ExceptionInterceptor : IInterceptor
{
    private readonly Logger _logger;

    public ExceptionInterceptor(Logger logger)
    {
        _logger = logger;
        Measure.Configure(new StatsdConfig());
    }

    public void Intercept(IInvocation invocation)
    {
        try
        {
            invocation.Proceed();
            //if ((Task<System.Threading.Tasks.VoidTaskReturn>) invocation.ReturnValue.Status == "Failed")
            //{
            //    throw new Exception(invocation.ReturnValue.Exception[0]);
            //}
        }
        catch (Exception e)
        {
            var errorMessage =
                String.Format(
                    "An error occurred while retrieving fund data. Error Message: {0} Inner Exception: {1}",
                    e.Message, e.InnerException != null ? e.InnerException.Message : "<None>");

            _logger.Log(errorMessage);
            Measure.Counter("Exception", 1);
            Measure.Event("Exception", errorMessage);
            throw;
        }

    }

I'm wiring this up in a module like so:

builder.RegisterType<DataConsumer>().
            As<IConsumer<DataRequest>>().
            EnableInterfaceInterceptors().
            InterceptedBy(typeof(ExceptionInterceptor));

builder.RegisterType<ExceptionInterceptor>().AsSelf();
var loggingInterceptor = new LoggingInterceptor(Logger);
builder.Register(c => loggingInterceptor);

However when I throw an exception in the method invocation this doesn't bubble up to the interceptor as an exception thrown, so it never enters the catch block. Is there any way to catch the intercepted method's exception in the interceptor?

I also can't access the invocation.ReturnValue.Status for some reason and as such can't test whether there was a thrown exception in order to re-throw.

Can anyone shed some light into what I might nor be doing right here?

Ta

Answer 1

I'm having a difficult time reproducing your issue due to a bit of incomplete information. For example, you noted that the IConsumer<T> interface is a MassTransit interface, but the interface in MassTransit isn't generic . It also specifically mentions that the interface is supposed to be a marker just for IoC containers, which may have some implications on your wire-up.

First, let's post a working exception handling example. To be self-contained, I'll create an IWorker<T> interface in place of IConsumer<T> and a simple implementation:

public interface IWorker<T>
{
    bool DoWork(T message);
}

public class StringWorker : IWorker<string>
{
    public bool DoWork(string message)
    {
        throw new DivideByZeroException();
    }
}

Now I'll create a simple exception logger that just pipes info to the console.

public class ExceptionLogger : IInterceptor
{
    private readonly TextWriter _output;

    public ExceptionLogger(TextWriter output)
    {
        _output = output;
    }

    public void Intercept(IInvocation invocation)
    {
        try
        {
            invocation.Proceed();
        }
        catch(Exception ex)
        {
            _output.WriteLine("Logged Exception: {0}", ex.Message);
            throw;
        }
    }
}

I can then wire it up and see it in action like this:

var builder = new ContainerBuilder();
builder.RegisterInstance(Console.Out).As<TextWriter>();
builder.RegisterType<ExceptionLogger>();
builder.RegisterType<StringWorker>()
       .As<IWorker<string>>()
       .EnableInterfaceInterceptors()
       .InterceptedBy(typeof(ExceptionLogger));

var container = builder.Build();
var worker = container.Resolve<IWorker<string>>();
worker.DoWork("Test!");

When I run this, I see on the console just before the program dies (with the unhandled exception - note my handler didn't swallow it, just logged it):

Logged Exception: Attempted to divide by zero.

So it's working.

I think there's more in your environment that may be causing trouble here. It could be something you think is unrelated but is actually important.

General things to investigate:

• Temporarily update your DataConsumer to throw an exception immediately inside one of the interface methods. After building your container, resolve a, IConsumer<DataRequest> and call that interface method. Does it get logged?
• Look at the places that you're expecting to see logging occur. Are you resolving and working with IConsumer<DataRequest> or something else? It's wrapping the interface methods, not the object type, so not all methods are covered.
• Set a breakpoint in the interceptor and see if any invocation at all is passing through it. It won't catch exceptions if it's not being hit. :)
• Check to see if there's any other exception handling policies or code in action. For example, some folks use the Enterprise Library exception handling block to deal with exceptions and that may be interfering with your work here.
• I've not used MassTransit, but check to see if there's any other object proxying going on. (Doubtful, but I know I've run into this with products like Glimpse, so you end up with proxies wrapped around proxies, which becomes challenging.)
• Is the exception actually happening in the place you think it is? It may be happening and getting handled somewhere that isn't wrapped with the proxy.

Basically, reduce the working pieces to the smallest set possible until you can see it working, then slowly expand until you find the place it breaks down. I don't know if any of these apply to your situation, but these are the things I'd start looking at if I was troubleshooting.

But... exception handling in an AOP fashion using interceptors does work , so it's something else going on that's causing the challenge.

Answer 2

It seems that it isn't possible for the exception thrown in the target proxy to be pushed up to the interceptor, and as such what I was trying to do didn't work. I ended up handling the exceptions at the class they occur.

Disappointed I didn't manage to get this to work the way I was intending to.