Add additional context and logging when a grain class throws from its constructor.

Author: ReubenBond

src/Orleans.Runtime/Activation/ActivationDataActivatorProvider.cs

@@ -85,12 +85,14 @@ private class ActivationDataActivator : IGrainContextActivator
             private readonly IGrainActivator _grainActivator;
             private readonly IServiceProvider _serviceProvider;
             private readonly GrainTypeSharedContext _sharedComponents;
+            private readonly ILogger<Grain> _grainLogger;
             private readonly Func<IGrainContext, WorkItemGroup> _createWorkItemGroup;
 
             public ActivationDataActivator(
                 IGrainActivator grainActivator,
                 IServiceProvider serviceProvider,
                 GrainTypeSharedContext sharedComponents,
+                ILogger<Grain> grainLogger,
                 ILogger<WorkItemGroup> workItemGroupLogger,
                 ILogger<ActivationTaskScheduler> activationTaskSchedulerLogger,
                 IOptions<SchedulingOptions> schedulingOptions)
@@ -101,6 +103,7 @@ public ActivationDataActivator(
                 _grainActivator = grainActivator;
                 _serviceProvider = serviceProvider;
                 _sharedComponents = sharedComponents;
+                _grainLogger = grainLogger;
                 _createWorkItemGroup = context => new WorkItemGroup(
                     context,
                     _workItemGroupLogger,
@@ -124,6 +127,10 @@ public IGrainContext CreateContext(GrainAddress activationAddress)
                     var instance = _grainActivator.CreateInstance(context);
                     context.SetGrainInstance(instance);
                 }
+                catch (Exception exception)
+                {
+                    _grainLogger.LogError(exception, "Failed to construct grain '{GrainId}'.", activationAddress.GrainId);
+                }
                 finally
                 {
                     RuntimeContext.ResetExecutionContext(originalContext);

src/Orleans.Runtime/Activation/DefaultGrainActivator.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -11,6 +11,7 @@ public class DefaultGrainActivator : IGrainActivator
     {
         private readonly ObjectFactory _grainInstanceFactory;
         private readonly GrainConstructorArgumentFactory _argumentFactory;
+        private readonly Type _grainClass;
 
         /// <summary>
         /// Initializes a new <see cref="DefaultGrainActivator"/> instance.
@@ -21,13 +22,23 @@ public DefaultGrainActivator(IServiceProvider serviceProvider, Type grainClass)
         {
             _argumentFactory = new GrainConstructorArgumentFactory(serviceProvider, grainClass);
             _grainInstanceFactory = ActivatorUtilities.CreateFactory(grainClass, _argumentFactory.ArgumentTypes);
+            _grainClass = grainClass;
         }
 
         /// <inheritdoc/>
         public object CreateInstance(IGrainContext context)
         {
-            var args = _argumentFactory.CreateArguments(context);
-            return _grainInstanceFactory(context.ActivationServices, args);
+            try
+            {
+                var args = _argumentFactory.CreateArguments(context);
+                return _grainInstanceFactory(context.ActivationServices, args);
+            }
+            catch (Exception exception)
+            {
+                throw new InvalidOperationException(
+                    $"Failed to create an instance of grain type '{_grainClass}'. See {nameof(Exception.InnerException)} for details.",
+                    exception);
+            }
         }
 
         /// <inheritdoc/>

src/Orleans.Runtime/Facet/GrainConstructorArgumentFactory.cs

@@ -37,7 +37,7 @@ public GrainConstructorArgumentFactory(IServiceProvider serviceProvider, Type gr
 
                 // Since the IAttributeToFactoryMapper is specific to the attribute specialization, we create a generic method to provide a attribute independent call pattern.
                 var getFactory = GetFactoryMethod.MakeGenericMethod(attribute.GetType());
-                var argumentFactory = (Factory<IGrainContext, object>)getFactory.Invoke(this, new object[] { serviceProvider, parameter, attribute, grainType });
+                var argumentFactory = (Factory<IGrainContext, object>)getFactory.Invoke(this, [serviceProvider, parameter, attribute, grainType]);
 
                 // Record the argument factory
                 _argumentFactories.Add(argumentFactory);

src/Orleans.Runtime/Facet/Persistent/PersistentStateAttributeMapper.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Reflection;
 using Microsoft.Extensions.DependencyInjection;
 using Orleans.Runtime;
@@ -9,7 +10,7 @@ namespace Orleans
     /// </summary>
     public class PersistentStateAttributeMapper : IAttributeToFactoryMapper<PersistentStateAttribute>
     {
-        private static readonly MethodInfo create = typeof(IPersistentStateFactory).GetMethod("Create");
+        private static readonly MethodInfo CreateMethodInfo = typeof(IPersistentStateFactory).GetMethod("Create");
 
         /// <inheritdoc/>
         public Factory<IGrainContext, object> GetFactory(ParameterInfo parameter, PersistentStateAttribute attribute)
@@ -20,15 +21,24 @@ public Factory<IGrainContext, object> GetFactory(ParameterInfo parameter, Persis
             {
                 config = new PersistentStateConfiguration() { StateName = parameter.Name, StorageName = attribute.StorageName };
             }
+
+            if (!parameter.ParameterType.IsGenericType || !typeof(IPersistentState<>).Equals(parameter.ParameterType.GetGenericTypeDefinition()))
+            {
+                throw new ArgumentException(
+                    $"Parameter '{parameter.Name}' on the constructor for '{parameter.Member.DeclaringType}' has an unsupported type, '{parameter.ParameterType}'. "
+                    + $"It must be an instance of generic type '{typeof(IPersistentState<>)}' because it has an associated [PersistentState(...)] attribute.",
+                    parameter.Name);
+            }
+
             // use generic type args to define collection type.
-            MethodInfo genericCreate = create.MakeGenericMethod(parameter.ParameterType.GetGenericArguments());
+            MethodInfo genericCreate = CreateMethodInfo.MakeGenericMethod(parameter.ParameterType.GetGenericArguments());
             return context => Create(context, genericCreate, config);
         }
 
-        private object Create(IGrainContext context, MethodInfo genericCreate, IPersistentStateConfiguration config)
+        private static object Create(IGrainContext context, MethodInfo genericCreate, IPersistentStateConfiguration config)
         {
             IPersistentStateFactory factory = context.ActivationServices.GetRequiredService<IPersistentStateFactory>();
-            object[] args = new object[] { context, config };
+            object[] args = [context, config];
             return genericCreate.Invoke(factory, args);
         }