[R&D Week Profiling] Add tests for sync over async scenarios (#6763)

## Summary of changes
Add sync-over-async scenarios 

## Reason for change
Investigate insights related to async anti-patterns

## Implementation details
Add scenarios for both .NET Framework and .NET Core

## Test coverage

## Other details
<!-- Fixes #{issue} -->

<!-- ⚠️ Note: where possible, please obtain 2 approvals prior to
merging. Unless CODEOWNERS specifies otherwise, for external teams it is
typically best to have one review from a team member, and one review
from apm-dotnet. Trivial changes do not require 2 reviews. -->

Author: chrisnas

profiler/src/Demos/Samples.BuggyBits/Controllers/CompanyInformationController.cs

@@ -3,6 +3,7 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2022 Datadog, Inc.
 // </copyright>
 
+using System.Threading;
 using BuggyBits.Models;
 using Microsoft.AspNetCore.Mvc;
 
@@ -17,12 +18,40 @@ public CompanyInformationController(DataLayer dataLayer)
             this.dataLayer = dataLayer;
         }
 
-        public IActionResult Index()
+        public IActionResult Index(bool shortLived=false)
         {
-            // bad blocking call
-            ViewData["TessGithubPage"] = dataLayer.GetTessGithubPage().Result;
+            if (shortLived)
+            {
+                ViewData["TessGithubPage"] = GetGitHubPageViaThread();
+                return View();
+            }
+            else
+            {
+                // bad blocking call
+                ViewData["TessGithubPage"] = dataLayer.GetTessGithubPage().Result;
+                return View();
+            }
+        }
+
+        private string GetGitHubPageViaThread()
+        {
+            string result = string.Empty;
+            Thread worker = new Thread(() =>
+            {
+                for (int i = 0; i < 5; i++)
+                {
+                    Thread.Sleep(100);
+                }
 
-            return View();
+                result = dataLayer.GetTessGithubPage().Result;
+                for (int i = 0; i < 5; i++)
+                {
+                    Thread.Sleep(100);
+                }
+            });
+            worker.Start();
+            worker.Join();
+            return result;
         }
 
         [HttpPost]

profiler/src/Demos/Samples.BuggyBits/Controllers/ProductsController.cs

@@ -4,6 +4,7 @@
 // </copyright>
 
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Text;
 using System.Threading;
@@ -23,6 +24,49 @@ public ProductsController(DataLayer dataLayer)
             this.dataLayer = dataLayer;
         }
 
+        public async Task<IActionResult> GetSyncOverAsync(bool withResultProperty)
+        {
+            var sw = new Stopwatch();
+            sw.Start();
+            IEnumerable<Product> products = null;
+            if (withResultProperty)
+            {
+                products = await dataLayer.GetAllProductWithResult($"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.Value}");
+            }
+            else
+            {
+                products = await dataLayer.GetAllProductGetAwaiterGetResult($"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.Value}");
+            }
+
+            var productsTable = new StringBuilder(1024 * 100);
+            productsTable.Append("<table><tr><th>Product Name</th><th>Description</th><th>Price</th></tr>");
+            foreach (var product in products)
+            {
+                productsTable.Append($"<tr><td>{product.ProductName}</td><td>{product.Description}</td><td>${product.Price}</td></tr>");
+            }
+
+            productsTable.Append("</table>");
+            sw.Stop();
+
+            ViewData["ElapsedTimeInMs"] = sw.ElapsedMilliseconds;
+            ViewData["ProductsTable"] = productsTable;
+            return View("Index");
+        }
+
+        // GET: Products with Result property - bad practice
+        [Route("Products/WithResult")]
+        public async Task<IActionResult> WithResult()
+        {
+            return await GetSyncOverAsync(true);
+        }
+
+        // GET: Products with GetAwaiter().GetResult() - bad practice
+        [Route("Products/GetAwaiterGetResult")]
+        public async Task<IActionResult> GetAwaiterGetResult()
+        {
+            return await GetSyncOverAsync(false);
+        }
+
         // GET: Products asynchronously
         [Route("Products/Async")]
         public async Task<IActionResult> Async()

profiler/src/Demos/Samples.BuggyBits/Models/DataLayer.cs

@@ -156,6 +156,36 @@ public List<Product> GetProductsOnSaleEx()
             return allProducts;
         }
 
+        // -------------------------------------------------------
+        // Different sync-over-async implementations
+        public async Task<IEnumerable<Product>> GetAllProductGetAwaiterGetResult(string rootPath)
+        {
+            // Note: sync-over-async is much slower so reduce the number of product to return
+            const int productCount = 2000;
+            var path = GetProductInfoRoot(rootPath);
+            var products = new List<Product>(productCount);
+            for (int id = 0; id < productCount; id++)
+            {
+                products.Add(GetProductAsync(path, id).GetAwaiter().GetResult());
+            }
+
+            return products;
+        }
+
+        public async Task<IEnumerable<Product>> GetAllProductWithResult(string rootPath)
+        {
+            // Note: sync-over-async is much slower so reduce the number of product to return
+            const int productCount = 2000;
+            var path = GetProductInfoRoot(rootPath);
+            var products = new List<Product>(productCount);
+            for (int id = 0; id < productCount; id++)
+            {
+                products.Add(GetProductAsync(path, id).Result);
+            }
+
+            return products;
+        }
+
         // -------------------------------------------------------
         // Different asynchronous implementations
         public async Task<IEnumerable<Product>> GetAllProductAsync(string rootPath)

profiler/src/Demos/Samples.BuggyBits/Program.cs

@@ -32,6 +32,9 @@ public enum Scenario
         EndpointsCount = 128, // Specific test with '.' in endpoint name
         Spin = 256, // Requests that take a long time
         Redirect = 512, // triggers HTTP redirect
+        GetAwaiterGetResult = 1024, // using GetAwaiter().GetResult() instead of await
+        UseResultProperty = 2048, // using Result property instead of GetAwaiter().GetResult()
+        ShortLived = 4096,      // short lived threads
     }
 
     public class Program

profiler/src/Demos/Samples.BuggyBits/SelfInvoker.cs

@@ -188,6 +188,21 @@ private List<string> GetEndpoints(string rootUrl)
                 {
                     urls.Add($"{rootUrl}/CompanyInformation");
                 }
+
+                if ((_scenario & Scenario.GetAwaiterGetResult) == Scenario.GetAwaiterGetResult)
+                {
+                    urls.Add($"{rootUrl}/Products/GetAwaiterGetResult");
+                }
+
+                if ((_scenario & Scenario.UseResultProperty) == Scenario.UseResultProperty)
+                {
+                    urls.Add($"{rootUrl}/Products/WithResult");
+                }
+
+                if ((_scenario & Scenario.ShortLived) == Scenario.ShortLived)
+                {
+                    urls.Add($"{rootUrl}/CompanyInformation?ShortLived=true");
+                }
             }
 
             return urls;

profiler/src/Demos/Samples.Computer01/ComputerService.cs

@@ -54,6 +54,7 @@ public class ComputerService
 #endif
         private ThreadSpikes _threadSpikes;
         private StringConcat _stringConcat;
+        private SyncOverAsync _syncOverAsync;
 
         public void StartService(Scenario scenario, int nbThreads, int parameter)
         {
@@ -185,6 +186,16 @@ public void StartService(Scenario scenario, int nbThreads, int parameter)
                     break;
 #endif
 
+                case Scenario.SyncOverAsyncWithGetAwaiterGetResult:
+                    _syncOverAsync = new SyncOverAsync(nbThreads, false);
+                    _syncOverAsync.Start();
+                    break;
+
+                case Scenario.SyncOverAsyncWithResult:
+                    _syncOverAsync = new SyncOverAsync(nbThreads, true);
+                    _syncOverAsync.Start();
+                    break;
+
                 default:
                     throw new ArgumentOutOfRangeException(nameof(scenario), $"Unsupported scenario #{_scenario}");
             }
@@ -317,6 +328,11 @@ public void StopService()
                     StopLinuxDlIteratePhdrDeadlock();
                     break;
 #endif
+
+                case Scenario.SyncOverAsyncWithGetAwaiterGetResult:
+                case Scenario.SyncOverAsyncWithResult:
+                    _syncOverAsync.Stop();
+                    break;
             }
         }
 
@@ -448,6 +464,14 @@ public void Run(Scenario scenario, int iterations, int nbThreads, int parameter)
                         RunStringConcat(parameter);
                         break;
 
+                    case Scenario.SyncOverAsyncWithGetAwaiterGetResult:
+                        RunSyncOverAsync(nbThreads, false);
+                        break;
+
+                    case Scenario.SyncOverAsyncWithResult:
+                        RunSyncOverAsync(nbThreads, true);
+                        break;
+
                     default:
                         throw new ArgumentOutOfRangeException(nameof(scenario), $"Unsupported scenario #{_scenario}");
                 }
@@ -971,6 +995,12 @@ private void RunStringConcat(int count)
             test.Run();
         }
 
+        private void RunSyncOverAsync(int threadCount, bool useResultProperty)
+        {
+            var test = new SyncOverAsync(threadCount, useResultProperty);
+            test.Run();
+        }
+
         public class MySpecialClassA
         {
         }

profiler/src/Demos/Samples.Computer01/Program.cs

@@ -41,6 +41,8 @@ public enum Scenario
         ThreadSpikes,
         StringConcat, // parameter = number of strings to concatenate
         LinuxDlIteratePhdrDeadlock,
+        SyncOverAsyncWithResult,
+        SyncOverAsyncWithGetAwaiterGetResult,
     }
 
     public class Program
@@ -78,6 +80,8 @@ public static void Main(string[] args)
             // 25: create thread spikes
             // 26: string concatenation
             // 27: custom dl_iterate_phdr deadlock
+            // 28: sync over async with Result property for n threads
+            // 29: sync over async with GetAwaiter().GetResult() for n threads
             //
             Console.WriteLine($"{Environment.NewLine}Usage:{Environment.NewLine} > {Process.GetCurrentProcess().ProcessName} " +
             $"[--service] [--iterations <number of iterations to execute>] " +

profiler/src/Demos/Samples.Computer01/SyncOverAsync.cs

@@ -0,0 +1,57 @@
+// <copyright file="SyncOverAsync.cs" company="Datadog">
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache 2 License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2022 Datadog, Inc.
+// </copyright>
+
+using System;
+using System.Threading.Tasks;
+
+namespace Samples.Computer01
+{
+    public class SyncOverAsync : ScenarioBase
+    {
+        private readonly bool _useResultProperty = false;
+
+        public SyncOverAsync(int nbThreads, bool useResultProperty)
+            : base(nbThreads)
+        {
+            _useResultProperty = useResultProperty;
+        }
+
+        public override void OnProcess()
+        {
+            Console.WriteLine("--> Before compute");
+            int result;
+            if (_useResultProperty)
+            {
+                result = Compute1().Result;
+            }
+            else
+            {
+                result = Compute1().GetAwaiter().GetResult();
+            }
+
+            Console.WriteLine($"<-- After compute = {result}");
+        }
+
+        private async Task<int> Compute1()
+        {
+            var result = await Compute2();
+            return result;
+        }
+
+        private async Task<int> Compute2()
+        {
+            var result = await Compute3();
+            return result;
+        }
+
+        private async Task<int> Compute3()
+        {
+            Console.WriteLine("in Compute3");
+            await Task.Delay(1000);
+
+            return 42;
+        }
+    }
+}