Async Cache and Async Cache Nonblocking exception handling changes

- Added support to post-process the exception in above mentioned two cache classes that
  creates a shallow copy of specific exception types to prevent stack trace proliferation and
  rethrows them, while propagating all other exceptions unchanged.
 - Added support for TaskCanceledException, TimeoutException and OperationCanceledException in this drop

Author: ananth7592

Microsoft.Azure.Cosmos/src/ExceptionHandlingUtility.cs

@@ -0,0 +1,52 @@
+// ------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+// ------------------------------------------------------------
+
+namespace Microsoft.Azure.Cosmos
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Text;
+    using System.Threading.Tasks;
+
+    /// <summary>
+    /// Utility for post-processing of exceptions.
+    /// </summary>
+    internal static class ExceptionHandlingUtility
+    {
+        /// <summary>
+        /// Creates a shallow copy of specific exception types (e.g., TaskCanceledException, TimeoutException, OperationCanceledException) 
+        /// to prevent excessive stack trace growth and rethrows them. All other exceptions are propagated as-is.
+        /// </summary>
+        /// <param name="e">The exception to process.</param>
+        /// <exception cref="TaskCanceledException">Thrown if the input exception is a TaskCanceledException.</exception>
+        /// <exception cref="TimeoutException">Thrown if the input exception is a TimeoutException.</exception>
+        /// <exception cref="OperationCanceledException">Thrown if the input exception is an OperationCanceledException.</exception>
+        public static void CloneAndRethrowException(Exception e)
+        {
+            if (e is TaskCanceledException)
+            {
+                TaskCanceledException taskCanceledEx = new TaskCanceledException(e.Message, e.InnerException);
+                taskCanceledEx.Data["Message"] = e.Data["Message"];
+                throw taskCanceledEx;
+            }
+
+            if (e is TimeoutException)
+            {
+                TimeoutException timeoutEx = new TimeoutException(e.Message, e.InnerException);
+                timeoutEx.Data["Message"] = e.Data["Message"];
+                throw timeoutEx;
+            }
+
+            if (e is OperationCanceledException)
+            {
+                OperationCanceledException operationCanceledEx = new OperationCanceledException(e.Message, e.InnerException);
+                operationCanceledEx.Data["Message"] = e.Data["Message"];
+                throw operationCanceledEx;
+            }
+
+            // For all other exceptions, throw the original exception.
+            throw e;
+        }
+    }
+}

Microsoft.Azure.Cosmos/src/Routing/AsyncCache.cs

@@ -148,11 +148,14 @@ public async Task<TValue> GetAsync(
             {
                 return await generator;
             }
-            catch (Exception) when (object.ReferenceEquals(actualValue, newLazyValue))
+            catch (Exception ex) when (object.ReferenceEquals(actualValue, newLazyValue))
             {
                 // If the lambda this thread added to values triggered an exception remove it from the cache.
-                this.TryRemoveValue(key, actualValue);
-                throw;
+                this.TryRemoveValue(key, actualValue);
+
+                // Creates a shallow copy of specific exception types to prevent stack trace proliferation 
+                // and rethrows them, while propagating all other exceptions unchanged.
+                ExceptionHandlingUtility.CloneAndRethrowException(ex);
             }
         }
 

Microsoft.Azure.Cosmos/src/Routing/AsyncCacheNonBlocking.cs

@@ -114,9 +114,11 @@ public async Task<TValue> GetAsync(
                             key,
                             removed,
                             e);
-                    }
-
-                    throw;
+                    }
+
+                    // Creates a shallow copy of specific exception types to prevent stack trace proliferation 
+                    // and rethrows them, while propagating all other exceptions unchanged.
+                    ExceptionHandlingUtility.CloneAndRethrowException(e);
                 }
 
                 return await this.UpdateCacheAndGetValueFromBackgroundTaskAsync(
@@ -158,7 +160,7 @@ public async Task<TValue> GetAsync(
                 this.values.TryRemove(key, out _);
                 throw;
             }
-        }
+        }
 
         public void Set(
            TKey key,
@@ -279,7 +281,7 @@ public AsyncLazyWithRefreshTask(
 
             public bool IsValueCreated => this.value != null;
 
-            public Task<T> GetValueAsync(
+            public Task<T> GetValueAsync(
                 Func<T, Task<T>> createValueFunc)
             {
                 // The task was already created so just return it.