HttpRequestMessage is disposed after the filters are resolved about autofac.webapi HOT 7 CLOSED

 builder.RegisterCallback(callback =>
            {
                callback.Registered += (sender, args) =>
                {
                    if (args.ComponentRegistration.Activator.LimitType == typeof(HttpRequestMessage))
                    {
                        return;
                    }

                    args.ComponentRegistration.Preparing += (sender2, arg2) =>
                    {
                        try
                        {
                            var message = arg2.Context.Resolve<HttpRequestMessage>();
                            if (!message.Headers.Contains("Preparing"))
                            {
                                message.Headers.Add("Preparing", DateTime.Now.ToString());
                            }
                            
                        }
                        catch (Exception)
                        {
                        }
                    };

                    args.ComponentRegistration.Activated += (sender2, arg2) =>
                    {
                        try
                        {
                            var message = arg2.Context.Resolve<HttpRequestMessage>();
                            if (!message.Headers.Contains("Activated"))
                            {
                                message.Headers.Add("Activated", DateTime.Now.ToString());
                            }

                        }
                        catch (Exception)
                        {
                        }
                    };
                };
            });

public class WebApiApplication : System.Web.HttpApplication
    {
        protected void Application_Start()
        {
            var builder = new ContainerBuilder();

            // Get your HttpConfiguration.
            var config = GlobalConfiguration.Configuration;

            builder.RegisterCallback( ... );
            ....

            // builder.RegisterHttpRequestMessage(config);
          // Autofac code
            builder.Register(c => HttpRequestMessageProvider.Current)
               .InstancePerRequest()
                .ExternallyOwned(); // <--- this was added
               ...
        }
    }

    // Copy from Autofac source code
    /// <summary>
    /// A delegating handler that updates the current dependency scope
    /// with the current <see cref="HttpRequestMessage"/>.
    /// </summary>
    public class CurrentRequestHandler : DelegatingHandler
    {
        /// <summary>
        /// Sends an HTTP request to the inner handler to send to the server as an asynchronous operation.
        /// </summary>
        /// <param name="request">The HTTP request message to send to the server.</param>
        /// <param name="cancellationToken">A cancellation token to cancel operation.</param>
        /// <returns>
        /// Returns <see cref="System.Threading.Tasks.Task{T}" />. The task object representing the asynchronous operation.
        /// </returns>
        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            UpdateScopeWithHttpRequestMessage(request);

            return base.SendAsync(request, cancellationToken);
        }

        /// <summary>
        /// Updates the current dependency scope with current HTTP request message.
        /// </summary>
        /// <param name="request">The HTTP request message.</param>
        internal static void UpdateScopeWithHttpRequestMessage(HttpRequestMessage request)
        {
            HttpRequestMessageProvider.Current = request;
        }
    }

    public static class HttpRequestMessageProvider
    {
        private static readonly string Key = Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture).Substring(0, 12);

        internal static HttpRequestMessage Current
        {
            get
            {
                var wrapper = (HttpRequestMessageWrapper)CallContext.LogicalGetData(Key);
                return wrapper?.Message;
            }

            set
            {
                var wrapper = value == null ? null : new HttpRequestMessageWrapper(value);
                CallContext.LogicalSetData(Key, wrapper);
            }
        }

        [Serializable]
        private sealed class HttpRequestMessageWrapper : MarshalByRefObject
        {
            [NonSerialized]
            [SuppressMessage("SA1401", "SA1401", Justification = "Field is only used during testing.")]
            internal readonly HttpRequestMessage Message;

            internal HttpRequestMessageWrapper(HttpRequestMessage message)
            {
                Message = message;
            }
        }
    }