Improve Redis session refresh logic:

- Introduce IdleTimeoutRefreshRatio constant (0.3) for configurable refresh threshold
- Refresh session TTL only when remaining time is below threshold
- Ensure session TTL is refreshed correctly on writes (Set/SetAsync)

Author: claudiamurialdo

dotnet/src/dotnetcore/GxNetCoreStartup/SessionHelper.cs

@@ -13,57 +13,70 @@ public class CustomRedisSessionStore : IDistributedCache
 		private readonly TimeSpan _idleTimeout;
 		private readonly TimeSpan _refreshThreshold;
 		private readonly string _instanceName;
-
+		// Refresh only if remaining TTL is below 35% of the original idle timeout.
+		private const double IdleTimeoutRefreshRatio= 0.3; // 30%
 		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));
+			_refreshThreshold = TimeSpan.FromTicks((long)(idleTimeout.Ticks * IdleTimeoutRefreshRatio));
 			_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 byte[] Get(string key)
+		{
+			string redisKey = FormatKey(key);
+			var value = _db.StringGet(redisKey);
+
+			if (value.HasValue)
+				RefreshKeyIfNeeded(redisKey);
 
+			return value;
+		}
 		public async Task<byte[]> GetAsync(string key, CancellationToken token = default)
 		{
 			string redisKey = FormatKey(key);
 			var value = await _db.StringGetAsync(redisKey);
 
-			await RefreshKeyIfNeededAsync(redisKey);
+			if (value.HasValue)
+			{
+				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);
-			}
+			RefreshKeyIfNeeded(redisKey);
 		}
 		private bool ShouldRefreshKey(TimeSpan? ttl)
 		{
-			return ttl.HasValue && ttl.Value < _refreshThreshold;
+			return ttl.HasValue && ttl.Value < _refreshThreshold && ttl.Value > TimeSpan.Zero; ;
 		}
 		public async Task RefreshAsync(string key, CancellationToken token = default)
 		{
 			string redisKey = FormatKey(key);
 			await RefreshKeyIfNeededAsync(redisKey);
 		}
+		private void RefreshKeyIfNeeded(string redisKey)
+		{
+			var ttl = _db.KeyTimeToLive(redisKey);
+			if (ShouldRefreshKey(ttl))
+			{
+				_db.KeyExpire(redisKey, _idleTimeout);
+			}
+		}
 		private async Task RefreshKeyIfNeededAsync(string redisKey)
 		{
 			var ttl = await _db.KeyTimeToLiveAsync(redisKey);
 
 			if (ShouldRefreshKey(ttl))
 			{
-				_ = _db.KeyExpireAsync(redisKey, _idleTimeout);
+				await _db.KeyExpireAsync(redisKey, _idleTimeout);
 			}
 		}
 		public void Remove(string key) => _db.KeyDelete(FormatKey(key));
@@ -73,13 +86,13 @@ public Task RemoveAsync(string key, CancellationToken token = default)
 
 		public void Set(string key, byte[] value, DistributedCacheEntryOptions options)
 		{
-			_db.StringSet(FormatKey(key), value, _idleTimeout);
+			TimeSpan expiry = options?.AbsoluteExpirationRelativeToNow ?? _idleTimeout;
+			_db.StringSet(FormatKey(key), value, expiry);
 		}
-
 		public Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options, CancellationToken token = default)
 		{
-			return _db.StringSetAsync(FormatKey(key), value, _idleTimeout);
+			TimeSpan expiry = options?.AbsoluteExpirationRelativeToNow ?? _idleTimeout;
+			return _db.StringSetAsync(FormatKey(key), value, expiry);
 		}
 	}
-
 }