Make distributed session loading asynchronous to improve scalability (#1195)

claudiamurialdo · claudiamurialdo · web-flow · commit bb22cbbe7d67 · 2025-10-08T19:41:01.000-03:00
* Introduce CustomRedisSessionStore to reduce excessive EXPIRE operations in Redis and improve session handling performance.
Converted ProcessRestRequest method in GXRouting.cs to fully async implementation.

* Ensures sessions load asynchronously

* Apply suggestions from FAzzatto
-Simplified exception handling by replacing await Task.FromException(ex) with throw
-Refactored to throw PageNotFoundException directly when the route cannot be handled, removed unnecessary result task, and moved CommitSessionAsync() to a finally block for clearer async flow

Removed CustomRedisSessionStore which was previously used as an experiment to reduce synchronous Redis Refresh calls. Now that LoadAsync is executed at the start of each request, those synchronous Refresh calls no longer appear to be necessary, because they were caused by the previous synchronous load.

* Refactored method to remove the result variable and await tasks directly, preserving the original behavior.

---------

Co-authored-by: claudiamurialdo &lt;c.murialdo@globant.com&gt;
diff --git a/dotnet/src/dotnetcore/GxClasses.Web/Middleware/GXRouting.cs b/dotnet/src/dotnetcore/GxClasses.Web/Middleware/GXRouting.cs
@@ -62,10 +62,10 @@ public GXRouting(string baseURL)
 		}
 
 		static public List<ControllerInfo> GetRouteController(Dictionary<string, string> apiPaths,
-											Dictionary<string, List<string>> sValid,
-											Dictionary<string, Dictionary<string, SingleMap>> sMap,
-											Dictionary<string, Dictionary<Tuple<string, string>, string>> sMapData,
-											string basePath, string verb, string path)
+																				Dictionary<string, List<string>> sValid,
+																				Dictionary<string, Dictionary<string, SingleMap>> sMap,
+																				Dictionary<string, Dictionary<Tuple<string, string>, string>> sMapData,
+																				string basePath, string verb, string path)
 		{
 			List<ControllerInfo> result = new List<ControllerInfo>();
 			string parms = string.Empty;
@@ -78,10 +78,10 @@ static public List<ControllerInfo> GetRouteController(Dictionary<string, string>
 					int questionMarkIdx = path.IndexOf(QUESTIONMARK);
 					string controller;
 					if (apiPaths.ContainsKey(basePath)
-						&& sValid.ContainsKey(basePath)
-						&& sMap.ContainsKey(basePath)
-						&& sMapData.ContainsKey(basePath)
-						)
+							&& sValid.ContainsKey(basePath)
+							&& sMap.ContainsKey(basePath)
+							&& sMapData.ContainsKey(basePath)
+							)
 					{
 						if (sValid[basePath].Contains(path.ToLower()))
 						{
@@ -174,21 +174,20 @@ internal async Task RouteHttpService(HttpContext context)
 				HandlerFactory handlerFactory = new HandlerFactory();
 				await handlerFactory.Invoke(context);
 			}
-			catch (Exception ex)
+			catch
 			{
-				await Task.FromException(ex);
+				throw;
 			}
 		}
-		public Task ProcessRestRequest(HttpContext context)
+		public async Task ProcessRestRequest(HttpContext context)
 		{
 			try
 			{
-				if (context.GetType()==typeof(DefaultHttpContext))
+				if (context.GetType() == typeof(DefaultHttpContext))
 				{
 					IHttpContextAccessor contextAccessor = context.RequestServices.GetService<IHttpContextAccessor>();
 					context = new GxHttpContextAccesor(contextAccessor);
 				}
-				Task result = Task.CompletedTask;
 				string path = context.Request.Path.ToString();
 				string actualPath = string.Empty;
 				bool isServiceInPath = ServiceInPath(path, out actualPath);
@@ -214,43 +213,46 @@ public Task ProcessRestRequest(HttpContext context)
 							}
 							string controllerPath = path.ToLower().Split(actualPath).Last<string>();
 							controllerWithParms = controllerPath.Split(QUESTIONMARK).First<string>();
-					
+
 						}
 					}
 					else
 					{
-						if (path.Contains(oauthRoute) && (AzureDeploy.GAM == "true")) 
-							return (RouteHttpService(context));
+						if (path.Contains(oauthRoute) && (AzureDeploy.GAM == "true"))
+						{
+							await (RouteHttpService(context));
+							return;
+						}
 						controllerWithParms = GetGxRouteValue(path);
 						GXLogging.Debug(log, $"Running Azure functions. ControllerWithParms :{controllerWithParms} path:{path}");
 					}
-				
+
 					List<ControllerInfo> controllers = GetRouteController(servicesPathUrl, servicesValidPath, servicesMap, servicesMapData, actualPath, context.Request.Method, controllerWithParms);
 					GxRestWrapper controller = null;
 					ControllerInfo controllerInfo = controllers.FirstOrDefault(c => (controller = GetController(context, c)) != null);
-					
+
 
 					if (controller != null)
 					{
 						if (HttpMethods.IsGet(context.Request.Method) && (controllerInfo.Verb == null || HttpMethods.IsGet(controllerInfo.Verb)))
 						{
-							result = controller.Get(controllerInfo.Parameters);
+							await controller.Get(controllerInfo.Parameters);
 						}
 						else if (HttpMethods.IsPost(context.Request.Method) && (controllerInfo.Verb == null || HttpMethods.IsPost(controllerInfo.Verb)))
 						{
-							result = controller.Post();
+							await controller.Post();
 						}
 						else if (HttpMethods.IsDelete(context.Request.Method) && (controllerInfo.Verb == null || HttpMethods.IsDelete(controllerInfo.Verb)))
 						{
-							result = controller.Delete(controllerInfo.Parameters);
+							await controller.Delete(controllerInfo.Parameters);
 						}
 						else if (HttpMethods.IsPut(context.Request.Method) && (controllerInfo.Verb == null || HttpMethods.IsPut(controllerInfo.Verb)))
 						{
-							result = controller.Put(controllerInfo.Parameters);
+							await controller.Put(controllerInfo.Parameters);
 						}
 						else if (HttpMethods.IsPatch(context.Request.Method) && (controllerInfo.Verb == null || HttpMethods.IsPatch(controllerInfo.Verb)))
 						{
-							result = controller.Patch(controllerInfo.Parameters);
+							await controller.Patch(controllerInfo.Parameters);
 						}
 						else if (HttpMethods.IsOptions(context.Request.Method))
 						{
@@ -284,18 +286,20 @@ public Task ProcessRestRequest(HttpContext context)
 					{
 						GXLogging.Error(log, $"ProcessRestRequest controller not found path:{path} controllerWithParms:{controllerWithParms}");
 						context.Response.Headers.Clear();
-						result = Task.FromException(new PageNotFoundException(path));
+						throw new PageNotFoundException(path);
 					}
 				}
-				context.CommitSession();
-
-				return result;
+				
 			}
 			catch (Exception ex)
 			{
 				GXLogging.Error(log, "ProcessRestRequest", ex);
 				HttpHelper.SetUnexpectedError(context, HttpStatusCode.InternalServerError, ex);
-				return Task.FromException(ex);
+				throw;
+			}
+			finally
+			{
+				await context.CommitSessionAsync();
 			}
 		}
 
@@ -374,20 +378,21 @@ public bool ServiceInPath(String path, out String actualPath)
 					return true;
 				}
 			}
-			else {
+			else
+			{
 				return true;
-			}						
+			}
 		}
 
-		private String FindPath(string innerPath, Dictionary<string,string > servicesPathUrl, bool startTxt)
+		private String FindPath(string innerPath, Dictionary<string, string> servicesPathUrl, bool startTxt)
 		{
 			string actualPath = String.Empty;
-			foreach (string subPath in from String subPath in servicesPathUrl.Keys									
-									select subPath)
+			foreach (string subPath in from String subPath in servicesPathUrl.Keys
+									   select subPath)
 			{
 				bool match = false;
 				innerPath = innerPath.ToLower();
-				match = (startTxt)? innerPath.StartsWith($"/{subPath.ToLower()}"): innerPath.Contains($"/{subPath.ToLower()}");
+				match = (startTxt) ? innerPath.StartsWith($"/{subPath.ToLower()}") : innerPath.Contains($"/{subPath.ToLower()}");
 				if (match)
 				{
 					actualPath = subPath.ToLower();
@@ -431,7 +436,7 @@ public GxRestWrapper GetController(HttpContext context, ControllerInfo controlle
 			bool privateDirExists = Directory.Exists(privateDir);
 
 			GXLogging.Debug(log, $"PrivateDir:{privateDir} asssemblycontroller:{asssemblycontroller}");
-			string svcFile=null;
+			string svcFile = null;
 			if (privateDirExists && File.Exists(Path.Combine(privateDir, $"{asssemblycontroller.ToLower()}.grp.json")))
 			{
 				controller = tmpController;
@@ -498,7 +503,7 @@ string SvcFile(string controller)
 				GXLogging.Warn(log, "Service file not found:" + controllerFullName);
 				return null;
 			}
-			
+
 		}
 		public void ServicesGroupSetting()
 		{
@@ -524,7 +529,7 @@ public void ServicesGroupSetting()
 								string mapPath = (m.BasePath.EndsWith("/")) ? m.BasePath : m.BasePath + "/";
 								string mapPathLower = mapPath.ToLower();
 								string mNameLower = m.Name.ToLower();
-								servicesPathUrl[mapPathLower]= mNameLower;
+								servicesPathUrl[mapPathLower] = mNameLower;
 								if (!RestAPIHelpers.ServiceAsController())
 								{
 									GXLogging.Debug(log, $"addServicesPathUrl key:{mapPathLower} value:{mNameLower}");
@@ -575,7 +580,8 @@ public void ServicesGroupSetting()
 						}
 					}
 				}
-			}catch (Exception ex)
+			}
+			catch (Exception ex)
 			{
 				GXLogging.Error(log, $"Error Loading Services Group Settings", ex);
 				throw;
@@ -676,7 +682,7 @@ public class Binding
 
 	[DataContract()]
 	public class MapGroup
-	{	
+	{
 		String _objectType;
 		String _name;
 		String _basePath;
diff --git a/dotnet/src/dotnetcore/GxClasses.Web/Middleware/HandlerFactory.cs b/dotnet/src/dotnetcore/GxClasses.Web/Middleware/HandlerFactory.cs
@@ -89,13 +89,13 @@ public async Task Invoke(HttpContext context)
 				}
 				else
 				{
-					await Task.FromException(new PageNotFoundException(url));
+					throw new PageNotFoundException(url);
 				}
 			}
 			catch (Exception ex)
 			{
 				GXLogging.Error(log, $"Handler Factory failed creating {url}", ex);
-				await Task.FromException(ex);
+				throw;
 			}
 		}
 		private static string ObjectUrl(string requestPath, string basePath) 
diff --git a/dotnet/src/dotnetcore/GxClasses/Domain/HttpSessionState.cs b/dotnet/src/dotnetcore/GxClasses/Domain/HttpSessionState.cs
@@ -1,9 +1,11 @@
 using System;
 using System.Collections;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Net;
 using System.Reflection;
+using System.Threading;
 using Microsoft.AspNetCore.Http;
 
 namespace GeneXus.Http
@@ -32,34 +34,13 @@ public static CookieCollection GetCookies(this CookieContainer container)
 			return allCookies;
 		}
 	}
-	internal class LockTracker : IDisposable
+	public static class LockTracker
 	{
-		private static Dictionary<string, LockTracker> _locks = new Dictionary<string, LockTracker>();
-		private int _activeUses = 0;
-		private readonly string _id;
+		private static readonly ConcurrentDictionary<string, SemaphoreSlim> _locks = new();
 
-		private LockTracker(string id) => _id = id;
-
-		internal static LockTracker Get(string id)
-		{
-			lock (_locks)
-			{
-				if (!_locks.ContainsKey(id))
-					_locks.Add(id, new LockTracker(id));
-				var res = _locks[id];
-				res._activeUses += 1;
-				return res;
-			}
-		}
-
-		void IDisposable.Dispose()
+		public static SemaphoreSlim Get(string sessionId)
 		{
-			lock (_locks)
-			{
-				_activeUses--;
-				if (_activeUses == 0)
-					_locks.Remove(_id);
-			}
+			return _locks.GetOrAdd(sessionId, _ => new SemaphoreSlim(1, 1));
 		}
 	}
 	internal class HttpSyncSessionState : HttpSessionState
diff --git a/dotnet/src/dotnetcore/GxNetCoreStartup/SessionHelper.cs b/dotnet/src/dotnetcore/GxNetCoreStartup/SessionHelper.cs
@@ -1,12 +1,13 @@
-using Microsoft.AspNetCore.Http;
-using Microsoft.Extensions.Caching.Distributed;
-using Microsoft.Extensions.Caching.StackExchangeRedis;
+using System;
 using System.Collections.Concurrent;
-using System.Threading.Tasks;
+using System.Linq;
 using System.Threading;
-using System;
+using System.Threading.Tasks;
 using GeneXus.Services;
-using System.Linq;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Caching.Distributed;
+using Microsoft.Extensions.Caching.StackExchangeRedis;
+using StackExchange.Redis;
 
 namespace GeneXus.Application
 {
@@ -63,9 +64,10 @@ public async Task Invoke(HttpContext context)
 		{
 			string host = context.Request.Host.Host;
 			string subdomain = host.Split('.').FirstOrDefault();
-			context.Items[TENANT_ID] = subdomain; 
+			context.Items[TENANT_ID] = subdomain;
 
 			await _next(context);
 		}
 	}
+
 }
diff --git a/dotnet/src/dotnetcore/GxNetCoreStartup/Startup.cs b/dotnet/src/dotnetcore/GxNetCoreStartup/Startup.cs
@@ -474,7 +474,7 @@ public void Configure(IApplicationBuilder app, Microsoft.AspNetCore.Hosting.IHos
 			}
 			app.UseRouting();
 			app.UseCookiePolicy();
-			app.UseSession();
+			app.UseAsyncSession();
 			app.UseStaticFiles();
 
 			ISessionService sessionService = GXSessionServiceFactory.GetProvider();
@@ -768,4 +768,36 @@ public void Apply(ApplicationModel application)
 			}
 		}
 	}
+	public static class SesssionAsyncExtensions
+	{
+		/// <summary>
+		/// Ensures sessions load asynchronously by calling LoadAsync before accessing session data,
+		/// forcing the session provider to avoid synchronous operations.
+		/// </summary>
+		/// <remarks>
+		/// https://learn.microsoft.com/en-us/aspnet/core/fundamentals/app-state?view=aspnetcore-5.0
+		/// The default session provider in ASP.NET Core will only load the session record from the underlying IDistributedCache store asynchronously if the
+		/// ISession.LoadAsync method is explicitly called before calling the TryGetValue, Set or Remove methods. 
+		/// Failure to call LoadAsync first will result in the underlying session record being loaded synchronously,
+		/// which could potentially impact the ability of an application to scale.
+		/// 
+		/// See also:
+		/// https://github.com/aspnet/Session/blob/master/src/Microsoft.AspNetCore.Session/DistributedSession.cs
+		/// https://github.com/dotnet/AspNetCore.Docs/issues/1840#issuecomment-454182594
+		/// </remarks>
+		public static IApplicationBuilder UseAsyncSession(this IApplicationBuilder app)
+		{
+			app.UseSession();
+			app.Use(async (context, next) =>
+			{
+				if (context.Session != null)
+				{
+					await context.Session.LoadAsync();
+				}
+				await next();
+			});
+			return app;
+		}
+	}
 }
+
diff --git a/dotnet/src/dotnetframework/GxClasses/Helpers/HttpHelper.cs b/dotnet/src/dotnetframework/GxClasses/Helpers/HttpHelper.cs

Original file line number	Diff line number	Diff line change
`@@ -62,10 +62,10 @@ public GXRouting(string baseURL)`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`static public List<ControllerInfo> GetRouteController(Dictionary<string, string> apiPaths,`
`65`		`- Dictionary<string, List<string>> sValid,`
`66`		`- Dictionary<string, Dictionary<string, SingleMap>> sMap,`
`67`		`- Dictionary<string, Dictionary<Tuple<string, string>, string>> sMapData,`
`68`		`- string basePath, string verb, string path)`
	`65`	`+ Dictionary<string, List<string>> sValid,`
	`66`	`+ Dictionary<string, Dictionary<string, SingleMap>> sMap,`
	`67`	`+ Dictionary<string, Dictionary<Tuple<string, string>, string>> sMapData,`
	`68`	`+ string basePath, string verb, string path)`
`69`	`69`	`{`
`70`	`70`	`List<ControllerInfo> result = new List<ControllerInfo>();`
`71`	`71`	`string parms = string.Empty;`
`@@ -78,10 +78,10 @@ static public List<ControllerInfo> GetRouteController(Dictionary<string, string>`
`78`	`78`	`int questionMarkIdx = path.IndexOf(QUESTIONMARK);`
`79`	`79`	`string controller;`
`80`	`80`	`if (apiPaths.ContainsKey(basePath)`
`81`		`- && sValid.ContainsKey(basePath)`
`82`		`- && sMap.ContainsKey(basePath)`
`83`		`- && sMapData.ContainsKey(basePath)`
`84`		`- )`
	`81`	`+ && sValid.ContainsKey(basePath)`
	`82`	`+ && sMap.ContainsKey(basePath)`
	`83`	`+ && sMapData.ContainsKey(basePath)`
	`84`	`+ )`
`85`	`85`	`{`
`86`	`86`	`if (sValid[basePath].Contains(path.ToLower()))`
`87`	`87`	`{`
`@@ -174,21 +174,20 @@ internal async Task RouteHttpService(HttpContext context)`
`174`	`174`	`HandlerFactory handlerFactory = new HandlerFactory();`
`175`	`175`	`await handlerFactory.Invoke(context);`
`176`	`176`	`}`
`177`		`- catch (Exception ex)`
	`177`	`+ catch`
`178`	`178`	`{`
`179`		`- await Task.FromException(ex);`
	`179`	`+ throw;`
`180`	`180`	`}`
`181`	`181`	`}`
`182`		`- public Task ProcessRestRequest(HttpContext context)`
	`182`	`+ public async Task ProcessRestRequest(HttpContext context)`
`183`	`183`	`{`
`184`	`184`	`try`
`185`	`185`	`{`
`186`		`- if (context.GetType()==typeof(DefaultHttpContext))`
	`186`	`+ if (context.GetType() == typeof(DefaultHttpContext))`
`187`	`187`	`{`
`188`	`188`	`IHttpContextAccessor contextAccessor = context.RequestServices.GetService<IHttpContextAccessor>();`
`189`	`189`	`context = new GxHttpContextAccesor(contextAccessor);`
`190`	`190`	`}`
`191`		`- Task result = Task.CompletedTask;`
`192`	`191`	`string path = context.Request.Path.ToString();`
`193`	`192`	`string actualPath = string.Empty;`
`194`	`193`	`bool isServiceInPath = ServiceInPath(path, out actualPath);`
`@@ -214,43 +213,46 @@ public Task ProcessRestRequest(HttpContext context)`
`214`	`213`	`}`
`215`	`214`	`string controllerPath = path.ToLower().Split(actualPath).Last<string>();`
`216`	`215`	`controllerWithParms = controllerPath.Split(QUESTIONMARK).First<string>();`
`217`		`-`
	`216`	`+`
`218`	`217`	`}`
`219`	`218`	`}`
`220`	`219`	`else`
`221`	`220`	`{`
`222`		`- if (path.Contains(oauthRoute) && (AzureDeploy.GAM == "true"))`
`223`		`- return (RouteHttpService(context));`
	`221`	`+ if (path.Contains(oauthRoute) && (AzureDeploy.GAM == "true"))`
	`222`	`+ {`
	`223`	`+ await (RouteHttpService(context));`
	`224`	`+ return;`
	`225`	`+ }`
`224`	`226`	`controllerWithParms = GetGxRouteValue(path);`
`225`	`227`	`GXLogging.Debug(log, $"Running Azure functions. ControllerWithParms :{controllerWithParms} path:{path}");`
`226`	`228`	`}`
`227`		`-`
	`229`	`+`
`228`	`230`	`List<ControllerInfo> controllers = GetRouteController(servicesPathUrl, servicesValidPath, servicesMap, servicesMapData, actualPath, context.Request.Method, controllerWithParms);`
`229`	`231`	`GxRestWrapper controller = null;`
`230`	`232`	`ControllerInfo controllerInfo = controllers.FirstOrDefault(c => (controller = GetController(context, c)) != null);`
`231`		`-`
	`233`	`+`
`232`	`234`
`233`	`235`	`if (controller != null)`
`234`	`236`	`{`
`235`	`237`	`if (HttpMethods.IsGet(context.Request.Method) && (controllerInfo.Verb == null \|\| HttpMethods.IsGet(controllerInfo.Verb)))`
`236`	`238`	`{`
`237`		`- result = controller.Get(controllerInfo.Parameters);`
	`239`	`+ await controller.Get(controllerInfo.Parameters);`
`238`	`240`	`}`
`239`	`241`	`else if (HttpMethods.IsPost(context.Request.Method) && (controllerInfo.Verb == null \|\| HttpMethods.IsPost(controllerInfo.Verb)))`
`240`	`242`	`{`
`241`		`- result = controller.Post();`
	`243`	`+ await controller.Post();`
`242`	`244`	`}`
`243`	`245`	`else if (HttpMethods.IsDelete(context.Request.Method) && (controllerInfo.Verb == null \|\| HttpMethods.IsDelete(controllerInfo.Verb)))`
`244`	`246`	`{`
`245`		`- result = controller.Delete(controllerInfo.Parameters);`
	`247`	`+ await controller.Delete(controllerInfo.Parameters);`
`246`	`248`	`}`
`247`	`249`	`else if (HttpMethods.IsPut(context.Request.Method) && (controllerInfo.Verb == null \|\| HttpMethods.IsPut(controllerInfo.Verb)))`
`248`	`250`	`{`
`249`		`- result = controller.Put(controllerInfo.Parameters);`
	`251`	`+ await controller.Put(controllerInfo.Parameters);`
`250`	`252`	`}`
`251`	`253`	`else if (HttpMethods.IsPatch(context.Request.Method) && (controllerInfo.Verb == null \|\| HttpMethods.IsPatch(controllerInfo.Verb)))`
`252`	`254`	`{`
`253`		`- result = controller.Patch(controllerInfo.Parameters);`
	`255`	`+ await controller.Patch(controllerInfo.Parameters);`
`254`	`256`	`}`
`255`	`257`	`else if (HttpMethods.IsOptions(context.Request.Method))`
`256`	`258`	`{`
`@@ -284,18 +286,20 @@ public Task ProcessRestRequest(HttpContext context)`
`284`	`286`	`{`
`285`	`287`	`GXLogging.Error(log, $"ProcessRestRequest controller not found path:{path} controllerWithParms:{controllerWithParms}");`
`286`	`288`	`context.Response.Headers.Clear();`
`287`		`- result = Task.FromException(new PageNotFoundException(path));`
	`289`	`+ throw new PageNotFoundException(path);`
`288`	`290`	`}`
`289`	`291`	`}`
`290`		`- context.CommitSession();`
`291`		`-`
`292`		`- return result;`
	`292`	`+`
`293`	`293`	`}`
`294`	`294`	`catch (Exception ex)`
`295`	`295`	`{`
`296`	`296`	`GXLogging.Error(log, "ProcessRestRequest", ex);`
`297`	`297`	`HttpHelper.SetUnexpectedError(context, HttpStatusCode.InternalServerError, ex);`
`298`		`- return Task.FromException(ex);`
	`298`	`+ throw;`
	`299`	`+ }`
	`300`	`+ finally`
	`301`	`+ {`
	`302`	`+ await context.CommitSessionAsync();`
`299`	`303`	`}`
`300`	`304`	`}`
`301`	`305`
`@@ -374,20 +378,21 @@ public bool ServiceInPath(String path, out String actualPath)`
`374`	`378`	`return true;`
`375`	`379`	`}`
`376`	`380`	`}`
`377`		`- else {`
	`381`	`+ else`
	`382`	`+ {`
`378`	`383`	`return true;`
`379`		`- }`
	`384`	`+ }`
`380`	`385`	`}`
`381`	`386`
`382`		`- private String FindPath(string innerPath, Dictionary<string,string > servicesPathUrl, bool startTxt)`
	`387`	`+ private String FindPath(string innerPath, Dictionary<string, string> servicesPathUrl, bool startTxt)`
`383`	`388`	`{`
`384`	`389`	`string actualPath = String.Empty;`
`385`		`- foreach (string subPath in from String subPath in servicesPathUrl.Keys`
`386`		`- select subPath)`
	`390`	`+ foreach (string subPath in from String subPath in servicesPathUrl.Keys`
	`391`	`+ select subPath)`
`387`	`392`	`{`
`388`	`393`	`bool match = false;`
`389`	`394`	`innerPath = innerPath.ToLower();`
`390`		`- match = (startTxt)? innerPath.StartsWith($"/{subPath.ToLower()}"): innerPath.Contains($"/{subPath.ToLower()}");`
	`395`	`+ match = (startTxt) ? innerPath.StartsWith($"/{subPath.ToLower()}") : innerPath.Contains($"/{subPath.ToLower()}");`
`391`	`396`	`if (match)`
`392`	`397`	`{`
`393`	`398`	`actualPath = subPath.ToLower();`
`@@ -431,7 +436,7 @@ public GxRestWrapper GetController(HttpContext context, ControllerInfo controlle`
`431`	`436`	`bool privateDirExists = Directory.Exists(privateDir);`
`432`	`437`
`433`	`438`	`GXLogging.Debug(log, $"PrivateDir:{privateDir} asssemblycontroller:{asssemblycontroller}");`
`434`		`- string svcFile=null;`
	`439`	`+ string svcFile = null;`
`435`	`440`	`if (privateDirExists && File.Exists(Path.Combine(privateDir, $"{asssemblycontroller.ToLower()}.grp.json")))`
`436`	`441`	`{`
`437`	`442`	`controller = tmpController;`
`@@ -498,7 +503,7 @@ string SvcFile(string controller)`
`498`	`503`	`GXLogging.Warn(log, "Service file not found:" + controllerFullName);`
`499`	`504`	`return null;`
`500`	`505`	`}`
`501`		`-`
	`506`	`+`
`502`	`507`	`}`
`503`	`508`	`public void ServicesGroupSetting()`
`504`	`509`	`{`
`@@ -524,7 +529,7 @@ public void ServicesGroupSetting()`
`524`	`529`	`string mapPath = (m.BasePath.EndsWith("/")) ? m.BasePath : m.BasePath + "/";`
`525`	`530`	`string mapPathLower = mapPath.ToLower();`
`526`	`531`	`string mNameLower = m.Name.ToLower();`
`527`		`- servicesPathUrl[mapPathLower]= mNameLower;`
	`532`	`+ servicesPathUrl[mapPathLower] = mNameLower;`
`528`	`533`	`if (!RestAPIHelpers.ServiceAsController())`
`529`	`534`	`{`
`530`	`535`	`GXLogging.Debug(log, $"addServicesPathUrl key:{mapPathLower} value:{mNameLower}");`
`@@ -575,7 +580,8 @@ public void ServicesGroupSetting()`
`575`	`580`	`}`
`576`	`581`	`}`
`577`	`582`	`}`
`578`		`- }catch (Exception ex)`
	`583`	`+ }`
	`584`	`+ catch (Exception ex)`
`579`	`585`	`{`
`580`	`586`	`GXLogging.Error(log, $"Error Loading Services Group Settings", ex);`
`581`	`587`	`throw;`
`@@ -676,7 +682,7 @@ public class Binding`
`676`	`682`
`677`	`683`	`[DataContract()]`
`678`	`684`	`public class MapGroup`
`679`		`- {`
	`685`	`+ {`
`680`	`686`	`String _objectType;`
`681`	`687`	`String _name;`
`682`	`688`	`String _basePath;`
Original file line number	Diff line number	Diff line change
`@@ -89,13 +89,13 @@ public async Task Invoke(HttpContext context)`
`89`	`89`	`}`
`90`	`90`	`else`
`91`	`91`	`{`
`92`		`- await Task.FromException(new PageNotFoundException(url));`
	`92`	`+ throw new PageNotFoundException(url);`
`93`	`93`	`}`
`94`	`94`	`}`
`95`	`95`	`catch (Exception ex)`
`96`	`96`	`{`
`97`	`97`	`GXLogging.Error(log, $"Handler Factory failed creating {url}", ex);`
`98`		`- await Task.FromException(ex);`
	`98`	`+ throw;`
`99`	`99`	`}`
`100`	`100`	`}`
`101`	`101`	`private static string ObjectUrl(string requestPath, string basePath)`
Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,13 @@`
`1`		`-using Microsoft.AspNetCore.Http;`
`2`		`-using Microsoft.Extensions.Caching.Distributed;`
`3`		`-using Microsoft.Extensions.Caching.StackExchangeRedis;`
	`1`	`+using System;`
`4`	`2`	`using System.Collections.Concurrent;`
`5`		`-using System.Threading.Tasks;`
	`3`	`+using System.Linq;`
`6`	`4`	`using System.Threading;`
`7`		`-using System;`
	`5`	`+using System.Threading.Tasks;`
`8`	`6`	`using GeneXus.Services;`
`9`		`-using System.Linq;`
	`7`	`+using Microsoft.AspNetCore.Http;`
	`8`	`+using Microsoft.Extensions.Caching.Distributed;`
	`9`	`+using Microsoft.Extensions.Caching.StackExchangeRedis;`
	`10`	`+using StackExchange.Redis;`
`10`	`11`
`11`	`12`	`namespace GeneXus.Application`
`12`	`13`	`{`
`@@ -63,9 +64,10 @@ public async Task Invoke(HttpContext context)`
`63`	`64`	`{`
`64`	`65`	`string host = context.Request.Host.Host;`
`65`	`66`	`string subdomain = host.Split('.').FirstOrDefault();`
`66`		`- context.Items[TENANT_ID] = subdomain;`
	`67`	`+ context.Items[TENANT_ID] = subdomain;`
`67`	`68`
`68`	`69`	`await _next(context);`
`69`	`70`	`}`
`70`	`71`	`}`
	`72`	`+`
`71`	`73`	`}`