Merge branch 'microsoft:main' into Recording-Redis-Version

Author: vaishalitvv

VERSION

@@ -1 +1 @@
-2.0.19
+2.0.21

src/VirtualClient/VirtualClient.Actions.UnitTests/OpenSSL/OpenSslExecutorTests.cs

@@ -289,7 +289,7 @@ await executor.ExecuteAsync(CancellationToken.None)
         }
 
         [Test]
-        public async Task OpenSslExecutorExecutesGetOpensslVersion()
+        public async Task OpenSslExecutorExecutesGetOpensslVersionAsync()
         {
             this.SetupDefaultBehaviors();
             this.SetupOpensslVersionBehavior();
@@ -300,7 +300,7 @@ public async Task OpenSslExecutorExecutesGetOpensslVersion()
                 await executor.ExecuteAsync(CancellationToken.None)
                   .ConfigureAwait(false);
 
-                var messages = this.fixture.Logger.MessagesLogged($"{nameof(OpenSslExecutor)}.GetOpenSslVersion");
+                var messages = this.fixture.Logger.MessagesLogged($"{nameof(OpenSslExecutor)}.GetOpenSslVersionAsync");
                 Assert.IsNotEmpty(messages);
                 Assert.IsTrue(messages.All(msg => (msg.Item3 as EventContext).Properties["opensslVersion"].ToString() == "OpenSSL 3.5.0 8 Apr 2025 (Library: OpenSSL 3.5.0 8 Apr 2025)"));
             }

src/VirtualClient/VirtualClient.Actions/OpenSSL/OpenSslExecutor.cs

@@ -94,7 +94,7 @@ await this.InitializeWorkloadToolsetsAsync(cancellationToken)
         /// <summary>
         /// Gets openssl version by running openssl version command.
         /// </summary>
-        private async Task GetOpenSslVersion(CancellationToken cancellationToken, string toolCommand)
+        private async Task GetOpenSslVersionAsync(string toolCommand, CancellationToken cancellationToken)
         {
             // The OpenSSL version is not available in the workload output. We need to run a separate command to get the version.   
             // The command 'openssl version' will return the version of OpenSSL installed on the system.
@@ -115,7 +115,7 @@ private async Task GetOpenSslVersion(CancellationToken cancellationToken, string
                     }
 
                     this.MetadataContract.Add("OpenSSLVersion", opensslVersion, MetadataContractCategory.Dependencies);
-                    this.Logger.LogMessage($"{nameof(OpenSslExecutor)}.GetOpenSslVersion", LogLevel.Information, EventContext.Persisted().AddContext("opensslVersion", opensslVersion));
+                    this.Logger.LogMessage($"{nameof(OpenSslExecutor)}.GetOpenSslVersionAsync", LogLevel.Information, EventContext.Persisted().AddContext("opensslVersion", opensslVersion));
 
                     this.MetadataContract.AddForScenario(
                        "OpenSSL Speed",
@@ -126,14 +126,14 @@ private async Task GetOpenSslVersion(CancellationToken cancellationToken, string
 
         }
 
-        private void CaptureMetrics(IProcessProxy workloadProcess, string commandArguments, EventContext telemetryContext, CancellationToken cancellationToken)
+        private async Task CaptureMetricsAsync(IProcessProxy workloadProcess, string commandArguments, EventContext telemetryContext, CancellationToken cancellationToken)
         {
             if (workloadProcess.ExitCode == 0)
             {
                 try
                 {
                     // Retrieve OpenSSL version
-                    this.GetOpenSslVersion(cancellationToken, workloadProcess.FullCommand());
+                    await this.GetOpenSslVersionAsync(workloadProcess.FullCommand(), cancellationToken);
 
                     this.MetadataContract.Apply(telemetryContext);
 
@@ -189,7 +189,7 @@ private Task ExecuteWorkloadAsync(EventContext telemetryContext, CancellationTok
                                 await this.LogProcessDetailsAsync(process, telemetryContext, "OpenSSL", logToFile: true);
 
                                 process.ThrowIfWorkloadFailed();
-                                this.CaptureMetrics(process, commandArguments, telemetryContext, cancellationToken);
+                                await this.CaptureMetricsAsync(process, commandArguments, telemetryContext, cancellationToken);
                             }
                         }
                         finally

src/VirtualClient/VirtualClient.Core/Logging/SummaryFile/SummaryFileLogger.cs

@@ -57,7 +57,10 @@ public SummaryFileLogger(string filePath, IAsyncPolicy retryPolicy = null)
             if (string.IsNullOrWhiteSpace(filePath))
             {
                 PlatformSpecifics tempPlatformSpecifics = new PlatformSpecifics(Environment.OSVersion.Platform, RuntimeInformation.ProcessArchitecture);
-                filePath = tempPlatformSpecifics.Combine(tempPlatformSpecifics.LogsDirectory, "summary.txt");
+                ISystemInfo systemInfo = new SystemManagement();
+                string experimentId = systemInfo.ExperimentId;
+                string suffix = string.IsNullOrEmpty(experimentId) ? string.Empty : $"-{experimentId}";
+                filePath = tempPlatformSpecifics.Combine(tempPlatformSpecifics.LogsDirectory, $"summary{suffix}.txt");
             }
 
             this.filePath = filePath;

src/VirtualClient/VirtualClient.Monitors/FileUploadMonitor.cs

@@ -134,6 +134,9 @@ await this.Logger.LogMessageAsync($"{this.TypeName}.ProcessSummaryFileUploads",
                         // Upload the workload summary logs (e.g. metrics.csv) before exiting. We do this at the very end. Same as before, we do not
                         // honor the cancellation token until ALL files have been successfully processed.
                         await this.UploadCsvSummaryFilesAsync(blobManager, relatedContext);
+
+                        // Upload specific summary.txt at root level of logs directory.
+                        await this.UploadSummaryFileAsync(blobManager, relatedContext);
                     });
 
                     break;
@@ -233,6 +236,48 @@ private async Task<bool> UploadFilesAsync(IBlobManager blobManager, EventContext
             return filesFound;
         }
 
+        private async Task UploadSummaryFileAsync(IBlobManager blobManager, EventContext telemetryContext)
+        {
+            try
+            {
+                string suffix = string.IsNullOrEmpty(this.ExperimentId) ? string.Empty : $"-{this.ExperimentId}";
+                string summaryTxtFileLocation = Path.Combine(this.PlatformSpecifics.LogsDirectory, $"summary{suffix}.txt");
+                bool summaryTxtFileExists = this.fileSystem.File.Exists(summaryTxtFileLocation);
+                telemetryContext
+                    .AddContext(nameof(summaryTxtFileLocation), summaryTxtFileLocation)
+                    .AddContext(nameof(summaryTxtFileExists), summaryTxtFileExists);
+
+                if (summaryTxtFileExists)
+                {
+                    try
+                    {
+                        FileUploadDescriptor descriptor = this.CreateFileUploadDescriptor(
+                            new FileContext(
+                                this.fileSystem.FileInfo.New(summaryTxtFileLocation),
+                                "text/plain",
+                                Encoding.UTF8.WebName,
+                                this.ExperimentId,
+                                this.AgentId));
+
+                        await this.UploadFileAsync(blobManager, this.fileSystem, descriptor, CancellationToken.None);
+                    }
+                    catch (IOException exc) when (exc.Message.Contains("being used by another process", StringComparison.OrdinalIgnoreCase))
+                    {
+                        // It is common that there will be read/write access errors at certain times while
+                        // upload request files are being created at the same time as attempts to read. 
+                    }
+                    catch (Exception exc)
+                    {
+                        this.Logger.LogErrorMessage(exc, telemetryContext, LogLevel.Warning);
+                    }
+                }
+            }
+            catch (Exception exc)
+            {
+                this.Logger.LogErrorMessage(exc, telemetryContext, LogLevel.Error);
+            }
+        }
+
         private async Task UploadCsvSummaryFilesAsync(IBlobManager blobManager, EventContext telemetryContext)
         {
             try