Migrates more logic from the umb module over to netcore

src/Umbraco.Web.Common/Middleware/UmbracoRequestLoggingMiddleware.cs

@@ -8,6 +8,9 @@ using Umbraco.Core.Logging.Serilog.Enrichers;
 
 namespace Umbraco.Web.Common.Middleware
 {
+    /// <summary>
+    /// Adds request based serilog enrichers to the LogContext for each request
+    /// </summary>
     public class UmbracoRequestLoggingMiddleware : IMiddleware
     {
         private readonly HttpSessionIdEnricher _sessionIdEnricher;

src/Umbraco.Web.Common/Middleware/UmbracoRequestMiddleware.cs

@@ -6,6 +6,8 @@ using Umbraco.Web.Common.Lifetime;
 using Umbraco.Core;
 using Umbraco.Core.Logging;
 using System.Threading;
+using Umbraco.Core.Cache;
+using System.Collections.Generic;
 
 namespace Umbraco.Web.Common.Middleware
 {
@@ -18,22 +20,26 @@ namespace Umbraco.Web.Common.Middleware
         private readonly ILogger _logger;
         private readonly IUmbracoRequestLifetimeManager _umbracoRequestLifetimeManager;
         private readonly IUmbracoContextFactory _umbracoContextFactory;
+        private readonly IRequestCache _requestCache;
 
         public UmbracoRequestMiddleware(
             ILogger logger,
             IUmbracoRequestLifetimeManager umbracoRequestLifetimeManager,
-            IUmbracoContextFactory umbracoContextFactory)
+            IUmbracoContextFactory umbracoContextFactory,
+            IRequestCache requestCache)
         {
             _logger = logger;
             _umbracoRequestLifetimeManager = umbracoRequestLifetimeManager;
             _umbracoContextFactory = umbracoContextFactory;
+            _requestCache = requestCache;
         }
 
         public async Task InvokeAsync(HttpContext context, RequestDelegate next)
         {
-            // do not process if client-side request
+            var requestUri = new Uri(context.Request.GetEncodedUrl(), UriKind.RelativeOrAbsolute);
 
-            if (new Uri(context.Request.GetEncodedUrl(), UriKind.RelativeOrAbsolute).IsClientSideRequest())
+            // do not process if client-side request
+            if (requestUri.IsClientSideRequest())
             {
                 await next(context);
                 return;
@@ -43,6 +49,12 @@ namespace Umbraco.Web.Common.Middleware
 
             try
             {
+                if (umbracoContextReference.UmbracoContext.IsFrontEndUmbracoRequest)
+                { 
+                    LogHttpRequest.TryGetCurrentHttpRequestId(out var httpRequestId, _requestCache);
+                   _logger.Verbose<UmbracoRequestMiddleware>("Begin request [{HttpRequestId}]: {RequestUrl}", httpRequestId, requestUri);
+                }
+
                 try
                 {
                     _umbracoRequestLifetimeManager.InitRequest(context);
@@ -52,15 +64,80 @@ namespace Umbraco.Web.Common.Middleware
                     // try catch so we don't kill everything in all requests
                     _logger.Error<UmbracoRequestMiddleware>(ex);
                 }
-
-                await next(context);
-
-                _umbracoRequestLifetimeManager.EndRequest(context);
+                finally
+                {
+                    try
+                    {
+                        await next(context);
+                    }
+                    finally
+                    {
+                        _umbracoRequestLifetimeManager.EndRequest(context);
+                    }
+                }
             }
             finally
             {
-                umbracoContextReference.Dispose();
+                if (umbracoContextReference.UmbracoContext.IsFrontEndUmbracoRequest)
+                {
+                    LogHttpRequest.TryGetCurrentHttpRequestId(out var httpRequestId, _requestCache);
+                    _logger.Verbose<UmbracoRequestMiddleware>("End Request [{HttpRequestId}]: {RequestUrl} ({RequestDuration}ms)", httpRequestId, requestUri, DateTime.Now.Subtract(umbracoContextReference.UmbracoContext.ObjectCreated).TotalMilliseconds);
+                }
+
+                try
+                {
+                    DisposeRequestCacheItems(_logger, _requestCache, requestUri);
+                }
+                finally
+                {
+                    umbracoContextReference.Dispose();
+                }
             }
         }
+
+        /// <summary>
+        /// Any object that is in the HttpContext.Items collection that is IDisposable will get disposed on the end of the request
+        /// </summary>
+        /// <param name="http"></param>
+        /// <param name="requestCache"></param>
+        /// <param name="requestUri"></param>
+        private static void DisposeRequestCacheItems(ILogger logger, IRequestCache requestCache, Uri requestUri)
+        {
+            // do not process if client-side request
+            if (requestUri.IsClientSideRequest())
+                return;
+
+            //get a list of keys to dispose
+            var keys = new HashSet<string>();
+            foreach (var i in requestCache)
+            {
+                if (i.Value is IDisposeOnRequestEnd || i.Key is IDisposeOnRequestEnd)
+                {
+                    keys.Add(i.Key);
+                }
+            }
+            //dispose each item and key that was found as disposable.
+            foreach (var k in keys)
+            {
+                try
+                {
+                    requestCache.Get(k).DisposeIfDisposable();
+                }
+                catch (Exception ex)
+                {
+                    logger.Error<UmbracoRequestMiddleware>("Could not dispose item with key " + k, ex);
+                }
+                try
+                {
+                    k.DisposeIfDisposable();
+                }
+                catch (Exception ex)
+                {
+                    logger.Error<UmbracoRequestMiddleware>("Could not dispose item key " + k, ex);
+                }
+            }
+        }
+
+
     }
 }