unitycontainer / microsoft-logging Goto Github PK

Exception thrown: 'Unity.Exceptions.ResolutionFailedException' in Unity.Container.dll
An unhandled exception of type 'Unity.Exceptions.ResolutionFailedException' occurred in Unity.Container.dll
Resolution of the dependency failed, type = 'Unity.Microsoft.Logging.LoggingExtension', name = '(none)'.
Exception occurred while: Calling constructor Unity.Microsoft.Logging.LoggingExtension().
Exception is: MethodAccessException - Attempt by security transparent method 'Unity.Microsoft.Logging.LoggingExtension..ctor()' to access security critical method 'Microsoft.Extensions.Logging.LoggerFactory..ctor()' failed.
-----------------------------------------------
At the time of the exception, the container was: 
  Resolving Unity.Microsoft.Logging.LoggingExtension,(none)
  Calling constructor Unity.Microsoft.Logging.LoggingExtension()

public class LoggingExtension : UnityContainerExtension,
                                   IBuildPlanCreatorPolicy,
                                   IBuildPlanPolicy
    {
        #region Fields

        private readonly MethodInfo _createLoggerMethod = typeof(LoggingExtension).GetTypeInfo()
                                                                                  .GetDeclaredMethod(nameof(CreateLogger));

        #endregion


        #region Constructors

        //[InjectionConstructor]
        //public LoggingExtension()
        //{
        //    LoggerFactory = new LoggerFactory();
        //}

        //public LoggingExtension(ILoggerFactory factory)
        //{
        //    LoggerFactory = factory ?? new LoggerFactory();
        //}


        #endregion


        #region Public Members

        //public ILoggerFactory LoggerFactory { get; }

        #endregion


        #region IBuildPlanPolicy


        public void BuildUp(IBuilderContext context)
        {    
            context.Existing = null == context.ParentContext
                             ? context.ParentContext.Container.Resolve<ILoggerFactory>().CreateLogger(context.OriginalBuildKey.Name ?? string.Empty)
                             : context.Container.Resolve<ILoggerFactory>().CreateLogger(context.ParentContext.BuildKey.Type);
            context.BuildComplete = true;
        }

        #endregion


        #region IBuildPlanCreatorPolicy

        IBuildPlanPolicy IBuildPlanCreatorPolicy.CreatePlan(IBuilderContext context, INamedType buildKey)
        {
            var info = (context ?? throw new ArgumentNullException(nameof(context))).BuildKey
                                                                                    .Type
                                                                                    .GetTypeInfo();
            if (!info.IsGenericType) return this;

            var buildMethod = _createLoggerMethod.MakeGenericMethod(info.GenericTypeArguments.First())
                                                 .CreateDelegate(typeof(DynamicBuildPlanMethod));

            return new DynamicMethodBuildPlan((DynamicBuildPlanMethod)buildMethod, context.Container.Resolve<ILoggerFactory>());
        }

        #endregion


        #region Implementation

        private static void CreateLogger<T>(IBuilderContext context, ILoggerFactory loggerFactory)
        {
            context.Existing = loggerFactory.CreateLogger<T>();
            context.BuildComplete = true;
        }

        protected override void Initialize()
        {
            Context.Policies.Set(typeof(ILogger), string.Empty, typeof(IBuildPlanPolicy), this);
            Context.Policies.Set<IBuildPlanCreatorPolicy>(this, typeof(ILogger));
            Context.Policies.Set<IBuildPlanCreatorPolicy>(this, typeof(ILogger<>));
        }

        private delegate void DynamicBuildPlanMethod(IBuilderContext context, ILoggerFactory loggerFactory);

        private class DynamicMethodBuildPlan : IBuildPlanPolicy
        {
            private readonly DynamicBuildPlanMethod _buildMethod;
            private readonly ILoggerFactory _loggerFactory;

            /// <summary>
            /// 
            /// </summary>
            /// <param name="buildMethod"></param>
            /// <param name="loggerFactory"></param>
            public DynamicMethodBuildPlan(DynamicBuildPlanMethod buildMethod,
                                          ILoggerFactory loggerFactory)
            {
                _buildMethod = buildMethod;
                _loggerFactory = loggerFactory;
            }

            /// <summary>
            /// 
            /// </summary>
            /// <param name="context"></param>
            public void BuildUp(IBuilderContext context)
            {
                _buildMethod(context, _loggerFactory);
            }
        }

        #endregion
    }

    /// <summary>
    /// Called when [register].
    /// </summary>
    /// <param name="sender">The sender.</param>
    /// <param name="e">The <see cref="RegisterEventArgs"/> instance containing the event data.</param>
    private void OnRegister(object sender, RegisterEventArgs e)
    {
        System.Diagnostics.Debug.Assert(false, "OnRegister");
        if (e != null && e.TypeFrom != null && e.TypeFrom.IsInterface)
        {
            /*var interfaceInterceptor = new Interceptor<InterfaceInterceptor>();
            interfaceInterceptor.AddPolicies(e.TypeFrom, e.TypeTo, e.Name, Context.Policies);

            var interceptionBehavior = new InterceptionBehavior<LogMethodInterceptionBehavior>();
            interceptionBehavior.AddPolicies(e.TypeFrom, e.TypeTo, e.Name, Context.Policies);*/
        }
    }
}

    /// <summary>
    /// Invokes the specified input.
    /// </summary>
    /// <param name="input">The input.</param>
    /// <param name="getNext">The get next.</param>
    /// <returns>Object of type IMethodReturn</returns>
    [SecurityCritical]
    public IMethodReturn Invoke(IMethodInvocation input, GetNextInterceptionBehaviorDelegate getNext)
    {
        ArgumentValidator.ValidateForNotNull("getNext", getNext);

        // Log method invoked, by default we don't log method inputs
        bool logMethodInputs = false; 
        this.LogMethodInvoked(input, logMethodInputs);

        // Invoke the next behavior in the chain.
        IMethodReturn methodReturn = getNext()(input, getNext);

        // Log method completed, by default we don't log method outputs
        bool logMethodOutputs = false;
        this.LogMethodCompleted(input, methodReturn, logMethodOutputs);

        return methodReturn;
    }

    /// <summary>
    /// Gets the required interfaces.
    /// </summary>
    /// <returns>Object of type IEnumerable of Type</returns>
    [SecurityCritical]
    public IEnumerable<Type> GetRequiredInterfaces()
    {
        return Type.EmptyTypes;
    }

    /// <summary>
    /// Logs the method invoked.
    /// </summary>
    /// <param name="methodInvocation">The method invocation.</param>
    /// <param name="logMethodInputs">if set to <c>true</c> [log method inputs].</param>
    protected void LogMethodInvoked(IMethodInvocation methodInvocation, bool logMethodInputs)
    {
        ArgumentValidator.ValidateForNotNull("methodInvocation", methodInvocation);

        // Before invoking the method on the original target.
        Logger.Log(
            LogMessage.InvokedMethod,
            LogCategory.Information,
            methodInvocation.MethodBase.DeclaringType,
            methodInvocation.MethodBase.Name,
            methodInvocation.MethodBase);

        if (logMethodInputs)
        {
            if (methodInvocation.Arguments.Count > 0)
            {
                bool logAdditionalInformation = false;
                Logger.Log(LogMessage.MethodInputParameters, LogCategory.Information, logAdditionalInformation);

                for (int i = 0; i < methodInvocation.Arguments.Count; i++)
                {
                    Logger.Log(
                        LogMessage.ParameterNameAndValue,
                        LogCategory.Information,
                        logAdditionalInformation,
                        methodInvocation.Arguments.ParameterName(i),
                        methodInvocation.Arguments[i]);
                }
            }
        }
    }

    /// <summary>
    /// Logs the method completed.
    /// </summary>
    /// <param name="methodInvocation">The method invocation.</param>
    /// <param name="methodReturn">The method return.</param>
    /// <param name="logMethodOutputs">if set to <c>true</c> [log method outputs].</param>
    protected void LogMethodCompleted(
        IMethodInvocation methodInvocation,
        IMethodReturn methodReturn,
        bool logMethodOutputs)
    {
        ArgumentValidator.ValidateForNotNull("methodInvocation", methodInvocation);
        ArgumentValidator.ValidateForNotNull("methodReturn", methodReturn);

        // After invoking the method on the original target, log the method completion
        if (methodReturn.Exception != null)
        {
            // Log method exception
            Logger.Log(
                LogMessage.CompletedMethodWithException,
                LogCategory.Information,
                methodInvocation.MethodBase.DeclaringType,
                methodInvocation.MethodBase.Name,
                methodInvocation.MethodBase,
                methodReturn.Exception);

            // Log any inner exception
            if (methodReturn.Exception.InnerException != null)
            {
                bool logAdditionalInformation = false;
                Logger.Log(
                    LogMessage.InnerException,
                    LogCategory.Information,
                    logAdditionalInformation,
                    methodReturn.Exception.InnerException);
            }
        }
        else
        {
            // Log method method completed
            Logger.Log(
                LogMessage.CompletedMethod,
                LogCategory.Information,
                methodInvocation.MethodBase.DeclaringType,
                methodInvocation.MethodBase.Name,
                methodInvocation.MethodBase);

            // Log method outputs if required
            if (logMethodOutputs)
            {
                if (methodReturn.Outputs.Count > 0)
                {
                    bool logAdditionalInformation = false;
                    Logger.Log(LogMessage.MethodOutputParameters, LogCategory.Information, logAdditionalInformation);

                    for (int i = 0; i < methodReturn.Outputs.Count; i++)
                    {
                        Logger.Log(
                            LogMessage.ParameterNameAndValue,
                            LogCategory.Information,
                            logAdditionalInformation,
                            methodReturn.Outputs.ParameterName(i),
                            methodReturn.Outputs[i]);
                    }
                }

                if (methodReturn.ReturnValue != null)
                {
                    bool logAdditionalInformation = false;
                    Logger.Log(
                        LogMessage.MethodOutput,
                        LogCategory.Information,
                        logAdditionalInformation,
                        methodReturn.ReturnValue);
                }
            }
        }
    }
}

ILoggerFactory loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(new ConsoleLoggerProvider((text, logLevel) => logLevel >= LogLevel.Debug, false));

    var interceptionBehavior = new InterceptionBehavior<LogMethodInterceptionBehavior>();
    interceptionBehavior.AddPolicies(e.TypeFrom, e.TypeTo, e.Name, Context.Policies);*/
}