Cherry pick branch 'genexuslabs:custom-redis-session-store' into beta

(cherry picked from commit 95c3ff7)

# Conflicts:
#	dotnet/src/dotnetcore/GxNetCoreStartup/SessionHelper.cs
#	dotnet/src/dotnetcore/GxNetCoreStartup/Startup.cs

Author: claudiamurialdo

dotnet/src/dotnetcore/GxNetCoreStartup/SessionHelper.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Collections.Concurrent;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using GeneXus.Services;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Caching.Distributed;
+using StackExchange.Redis;
+
+namespace GeneXus.Application
+{
+
+	public class CustomRedisSessionStore : IDistributedCache
+	{
+		private readonly IDatabase _db;
+		private readonly TimeSpan _idleTimeout;
+		private readonly TimeSpan _refreshThreshold;
+		private readonly string _instanceName;
+
+		public CustomRedisSessionStore(string connectionString, TimeSpan idleTimeout, string instanceName)
+		{
+			var mux = ConnectionMultiplexer.Connect(connectionString);
+			_db = mux.GetDatabase();
+			_idleTimeout = idleTimeout;
+			_refreshThreshold = TimeSpan.FromTicks((long)(idleTimeout.Ticks * 0.2));
+			_instanceName = instanceName ?? string.Empty;
+		}
+
+		private string FormatKey(string key) => string.IsNullOrEmpty(_instanceName) ? key : $"{_instanceName}:{key}";
+
+		public byte[] Get(string key) => _db.StringGet(FormatKey(key));
+
+		public async Task<byte[]> GetAsync(string key, CancellationToken token = default)
+		{
+			string redisKey = FormatKey(key);
+			var value = await _db.StringGetAsync(redisKey);
+
+			await RefreshKeyIfNeededAsync(redisKey);
+
+			return value;
+		}
+
+		public void Refresh(string key)
+		{
+			string redisKey = FormatKey(key);
+
+			var ttl = _db.KeyTimeToLive(redisKey);
+
+			if (ShouldRefreshKey(ttl))
+			{
+				_db.KeyExpire(redisKey, _idleTimeout);
+			}
+		}
+		private bool ShouldRefreshKey(TimeSpan? ttl)
+		{
+			return ttl.HasValue && ttl.Value < _refreshThreshold;
+		}
+		public async Task RefreshAsync(string key, CancellationToken token = default)
+		{
+			string redisKey = FormatKey(key);
+			await RefreshKeyIfNeededAsync(redisKey);
+		}
+		private async Task RefreshKeyIfNeededAsync(string redisKey)
+		{
+			var ttl = await _db.KeyTimeToLiveAsync(redisKey);
+
+			if (ShouldRefreshKey(ttl))
+			{
+				_ = _db.KeyExpireAsync(redisKey, _idleTimeout);
+			}
+		}
+		public void Remove(string key) => _db.KeyDelete(FormatKey(key));
+
+		public Task RemoveAsync(string key, CancellationToken token = default)
+			=> _db.KeyDeleteAsync(FormatKey(key));
+
+		public void Set(string key, byte[] value, DistributedCacheEntryOptions options)
+		{
+			_db.StringSet(FormatKey(key), value, _idleTimeout);
+		}
+
+		public Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options, CancellationToken token = default)
+		{
+			return _db.StringSetAsync(FormatKey(key), value, _idleTimeout);
+		}
+	}
+
+}

dotnet/src/dotnetcore/GxNetCoreStartup/Startup.cs

@@ -12,6 +12,7 @@
 using GeneXus.Services.OpenTelemetry;
 using GeneXus.Utils;
 using GxClasses.Web.Middleware;
+
 using Microsoft.AspNetCore;
 using Microsoft.AspNetCore.Antiforgery;
 using Microsoft.AspNetCore.Builder;
@@ -36,6 +37,7 @@
 using Microsoft.Extensions.Diagnostics.HealthChecks;
 using Microsoft.Extensions.FileProviders;
 using Microsoft.Extensions.Logging;
+
 using StackExchange.Redis;
 
 namespace GeneXus.Application
@@ -64,6 +66,7 @@ public static void Main(string[] args)
 					LocatePhysicalLocalPath();
 
 				}
+
 				if (port == DEFAULT_PORT)
 				{
 					BuildWebHost(null).Run();
@@ -310,14 +313,13 @@ private void DefineCorsPolicy(IServiceCollection services)
 
 		private void ConfigureSessionService(IServiceCollection services, ISessionService sessionService)
 		{
+			
 			if (sessionService is GxRedisSession)
 			{
-				services.AddStackExchangeRedisCache(options =>
-				{
-					GXLogging.Info(log, $"Using Redis for Distributed session, ConnectionString:{sessionService.ConnectionString}, InstanceName: {sessionService.InstanceName}");
-					options.Configuration = sessionService.ConnectionString;
-					options.InstanceName = sessionService.InstanceName;
-				});
+				GXLogging.Info(log, $"Using Redis for Distributed session, ConnectionString:{sessionService.ConnectionString}, InstanceName: {sessionService.InstanceName}");
+
+				services.AddSingleton<IDistributedCache>(sp =>
+					new CustomRedisSessionStore(sessionService.ConnectionString, TimeSpan.FromMinutes(Preferences.SessionTimeout), sessionService.InstanceName));
 				services.AddDataProtection().PersistKeysToStackExchangeRedis(ConnectionMultiplexer.Connect(sessionService.ConnectionString), DATA_PROTECTION_KEYS).SetApplicationName(sessionService.InstanceName);
 			}
 			else if (sessionService is GxDatabaseSession)