diff --git a/Directory.Packages.props b/Directory.Packages.props
index 568b021b857d..4078c07ee0e8 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -6,6 +6,7 @@
   </PropertyGroup>
   <ItemGroup>
     <PackageVersion Include="Basic.CompilerLog.Util" Version="0.9.18" />
+    <PackageVersion Include="Azure.Monitor.OpenTelemetry.Exporter" Version="1.4.0" />
     <PackageVersion Include="AwesomeAssertions" Version="$(AwesomeAssertionsVersion)" />
     <PackageVersion Include="BenchmarkDotNet" Version="$(BenchmarkDotNetPackageVersion)" />
     <PackageVersion Include="AwesomeAssertions.Json" Version="$(AwesomeAssertionsJsonVersion)" />
@@ -112,6 +113,9 @@
     <PackageVersion Include="NuGet.ProjectModel" Version="$(NuGetProjectModelPackageVersion)" />
     <PackageVersion Include="NuGet.Protocol" Version="$(NuGetBuildTasksPackageVersion)" />
     <PackageVersion Include="NuGet.Versioning" Version="$(NuGetVersioningPackageVersion)" />
+    <PackageVersion Include="OpenTelemetry.Exporter.OpenTelemetryProtocol" Version="1.12.0" />
+    <PackageVersion Include="OpenTelemetry.Instrumentation.Http" Version="1.12.0" />
+    <PackageVersion Include="OpenTelemetry.Instrumentation.Runtime" Version="1.12.0" />
     <PackageVersion Include="runtime.linux-musl-x64.Microsoft.NETCore.DotNetHostResolver" Version="$(MicrosoftNETCoreDotNetHostResolverPackageVersion)" />
     <PackageVersion Include="runtime.linux-x64.Microsoft.NETCore.DotNetHostResolver" Version="$(MicrosoftNETCoreDotNetHostResolverPackageVersion)" />
     <PackageVersion Include="runtime.osx-x64.Microsoft.NETCore.DotNetHostResolver" Version="$(MicrosoftNETCoreDotNetHostResolverPackageVersion)" />
@@ -146,7 +150,6 @@
     <PackageVersion Include="xunit.assert" Version="$(XUnitVersion)" Condition="'$(IsTestProject)' != 'true'" />
     <PackageVersion Include="xunit.console" Version="$(XUnitVersion)" />
   </ItemGroup>
-
   <!-- Use different versions of Microsoft.Build.* depending on whether the output will be used in
        .NET Framework (VS) or only in the .NET SDK.
 
@@ -178,4 +181,4 @@
     <PackageVersion Include="Microsoft.Build.Utilities.Core" Version="$(MicrosoftBuildMinimumVersion)" />
     <PackageVersion Include="Microsoft.NET.StringTools" Version="$(MicrosoftBuildMinimumVersion)" />
   </ItemGroup>
-</Project>
+</Project>
\ No newline at end of file
diff --git a/src/Cli/Microsoft.DotNet.Cli.Utils/MSBuildForwardingAppWithoutLogging.cs b/src/Cli/Microsoft.DotNet.Cli.Utils/MSBuildForwardingAppWithoutLogging.cs
index e0dca709ac3c..0378bf4bd47c 100644
--- a/src/Cli/Microsoft.DotNet.Cli.Utils/MSBuildForwardingAppWithoutLogging.cs
+++ b/src/Cli/Microsoft.DotNet.Cli.Utils/MSBuildForwardingAppWithoutLogging.cs
@@ -199,7 +199,7 @@ private static string GetMSBuildExePath()
             MSBuildExeName);
     }
 
-    private static string GetMSBuildSDKsPath()
+    public static string GetMSBuildSDKsPath()
     {
         var envMSBuildSDKsPath = Environment.GetEnvironmentVariable("MSBuildSDKsPath");
 
diff --git a/src/Cli/Microsoft.DotNet.Cli.Utils/Microsoft.DotNet.Cli.Utils.csproj b/src/Cli/Microsoft.DotNet.Cli.Utils/Microsoft.DotNet.Cli.Utils.csproj
index b64200efdad3..7919f32bc40b 100644
--- a/src/Cli/Microsoft.DotNet.Cli.Utils/Microsoft.DotNet.Cli.Utils.csproj
+++ b/src/Cli/Microsoft.DotNet.Cli.Utils/Microsoft.DotNet.Cli.Utils.csproj
@@ -54,11 +54,8 @@
     <PackageReference Include="Microsoft.Build" ExcludeAssets="runtime" PrivateAssets="all" />
     <PackageReference Include="Microsoft.Build.Utilities.Core" ExcludeAssets="runtime" PrivateAssets="all" />
     <PackageReference Include="System.CommandLine" />
-    <PackageReference Include="System.IO.Hashing" />
-  </ItemGroup>
-
-  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETFramework'">
     <PackageReference Include="System.Diagnostics.DiagnosticSource" />
+    <PackageReference Include="System.IO.Hashing" />
   </ItemGroup>
 
   <Import Project="Sdk.targets" Sdk="Microsoft.NET.Sdk" />
diff --git a/src/Cli/Microsoft.DotNet.Cli.Utils/TelemetryEventEntry.cs b/src/Cli/Microsoft.DotNet.Cli.Utils/TelemetryEventEntry.cs
index 772e9845b678..8e85359775e6 100644
--- a/src/Cli/Microsoft.DotNet.Cli.Utils/TelemetryEventEntry.cs
+++ b/src/Cli/Microsoft.DotNet.Cli.Utils/TelemetryEventEntry.cs
@@ -11,7 +11,7 @@ public static class TelemetryEventEntry
     public static ITelemetryFilter TelemetryFilter { get; set; } = new BlockFilter();
 
     public static void TrackEvent(
-        string? eventName = null,
+        string eventName,
         IDictionary<string, string?>? properties = null,
         IDictionary<string, double>? measurements = null)
     {
@@ -32,7 +32,7 @@ public static void SendFiltered(object? o = null)
         }
     }
 
-    public static void Subscribe(Action<string?, IDictionary<string, string?>?, IDictionary<string, double>?> subscriber)
+    public static void Subscribe(Action<string, IDictionary<string, string?>?, IDictionary<string, double>?> subscriber)
     {
         void Handler(object? sender, InstrumentationEventArgs eventArgs)
         {
@@ -47,10 +47,11 @@ public sealed class PerformanceMeasurement : IDisposable
 {
     private readonly Stopwatch? _timer;
     private readonly Dictionary<string, double>? _data;
-    private readonly string? _name;
+    private readonly string _name;
 
     public PerformanceMeasurement(Dictionary<string, double>? data, string name)
     {
+        _name = name;
         // Measurement is a no-op if we don't have a dictionary to store the entry.
         if (data == null)
         {
@@ -58,13 +59,12 @@ public PerformanceMeasurement(Dictionary<string, double>? data, string name)
         }
 
         _data = data;
-        _name = name;
         _timer = Stopwatch.StartNew();
     }
 
     public void Dispose()
     {
-        if (_name is not null && _timer is not null)
+        if (_timer is not null)
         {
             _data?.Add(_name, _timer.Elapsed.TotalMilliseconds);
         }
@@ -82,7 +82,7 @@ public IEnumerable<ApplicationInsightsEntryFormat> Filter(object o)
 public class InstrumentationEventArgs : EventArgs
 {
     internal InstrumentationEventArgs(
-        string? eventName,
+        string eventName,
         IDictionary<string, string?>? properties,
         IDictionary<string, double>? measurements)
     {
@@ -91,17 +91,17 @@ internal InstrumentationEventArgs(
         Measurements = measurements;
     }
 
-    public string? EventName { get; }
+    public string EventName { get; }
     public IDictionary<string, string?>? Properties { get; }
     public IDictionary<string, double>? Measurements { get; }
 }
 
 public class ApplicationInsightsEntryFormat(
-    string? eventName = null,
+    string eventName,
     IDictionary<string, string?>? properties = null,
     IDictionary<string, double>? measurements = null)
 {
-    public string? EventName { get; } = eventName;
+    public string EventName { get; } = eventName;
     public IDictionary<string, string?>? Properties { get; } = properties;
     public IDictionary<string, double>? Measurements { get; } = measurements;
 
diff --git a/src/Cli/Microsoft.DotNet.InternalAbstractions/FilePath.cs b/src/Cli/Microsoft.DotNet.InternalAbstractions/FilePath.cs
index d9ad822f9517..f08c1f1a759a 100644
--- a/src/Cli/Microsoft.DotNet.InternalAbstractions/FilePath.cs
+++ b/src/Cli/Microsoft.DotNet.InternalAbstractions/FilePath.cs
@@ -1,34 +1,33 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-namespace Microsoft.Extensions.EnvironmentAbstractions
+namespace Microsoft.Extensions.EnvironmentAbstractions;
+
+public readonly struct FilePath
 {
-    public struct FilePath
-    {
-        public string Value { get; }
+    public string Value { get; }
 
-        /// <summary>
-        /// Create FilePath to represent an absolute file path. Note it may not exist.
-        /// </summary>
-        /// <param name="value">If the value is not rooted. Path.GetFullPath will be called during the constructor.</param>
-        public FilePath(string value)
+    /// <summary>
+    /// Create FilePath to represent an absolute file path. Note: It may not exist.
+    /// </summary>
+    /// <param name="value">If the value is not rooted. Path.GetFullPath will be called during the constructor.</param>
+    public FilePath(string value)
+    {
+        if (!Path.IsPathRooted(value))
         {
-            if (!Path.IsPathRooted(value))
-            {
-                value = Path.GetFullPath(value);
-            }
-
-            Value = value;
+            value = Path.GetFullPath(value);
         }
 
-        public override string ToString()
-        {
-            return Value;
-        }
+        Value = value;
+    }
 
-        public DirectoryPath GetDirectoryPath()
-        {
-            return new DirectoryPath(Path.GetDirectoryName(Value)!);
-        }
+    public override string ToString()
+    {
+        return Value;
+    }
+
+    public DirectoryPath GetDirectoryPath()
+    {
+        return new DirectoryPath(Path.GetDirectoryName(Value)!);
     }
 }
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/TemplateCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/TemplateCommand.cs
index 8e4e98c31bf3..50ba229fd8a4 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/TemplateCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/TemplateCommand.cs
@@ -156,7 +156,9 @@ internal async Task<NewCommandStatus> InvokeAsync(ParseResult parseResult, Cance
             CancellationTokenSource cancellationTokenSource = new();
             cancellationTokenSource.CancelAfter(ConstraintEvaluationTimeout);
 
+#pragma warning disable CA2025 // Do not pass 'IDisposable' instances into unawaited tasks
             Task<IReadOnlyList<TemplateConstraintResult>> constraintsEvaluation = ValidateConstraintsAsync(constraintManager, args.Template, args.IsForceFlagSpecified ? cancellationTokenSource.Token : cancellationToken);
+#pragma warning restore CA2025 // Do not pass 'IDisposable' instances into unawaited tasks
 
             if (!args.IsForceFlagSpecified)
             {
diff --git a/src/Cli/dotnet/CliSchema.cs b/src/Cli/dotnet/CliSchema.cs
index 67c816116a92..a76fb4fb8f9b 100644
--- a/src/Cli/dotnet/CliSchema.cs
+++ b/src/Cli/dotnet/CliSchema.cs
@@ -33,8 +33,20 @@ internal static class CliSchema
         TypeInfoResolver = new DefaultJsonTypeInfoResolver()
     };
 
-    public record ArgumentDetails(string? description, int order, bool hidden, string? helpName, string valueType, bool hasDefaultValue, object? defaultValue, ArityDetails arity);
-    public record ArityDetails(int minimum, int? maximum);
+    public record ArgumentDetails(
+        string? description,
+        int order,
+        bool hidden,
+        string? helpName,
+        string valueType,
+        bool hasDefaultValue,
+        object? defaultValue,
+        ArityDetails arity);
+
+    public record ArityDetails(
+        int minimum,
+        int? maximum);
+
     public record OptionDetails(
         string? description,
         bool hidden,
@@ -45,8 +57,8 @@ public record OptionDetails(
         object? defaultValue,
         ArityDetails arity,
         bool required,
-        bool recursive
-    );
+        bool recursive);
+
     public record CommandDetails(
         string? description,
         bool hidden,
@@ -54,6 +66,7 @@ public record CommandDetails(
         Dictionary<string, ArgumentDetails>? arguments,
         Dictionary<string, OptionDetails>? options,
         Dictionary<string, CommandDetails>? subcommands);
+
     public record RootCommandDetails(
         string name,
         string version,
@@ -65,7 +78,6 @@ public record RootCommandDetails(
         Dictionary<string, CommandDetails>? subcommands
     ) : CommandDetails(description, hidden, aliases, arguments, options, subcommands);
 
-
     public static void PrintCliSchema(CommandResult commandResult, TextWriter outputWriter, ITelemetry? telemetryClient)
     {
         var command = commandResult.Command;
@@ -74,7 +86,7 @@ public static void PrintCliSchema(CommandResult commandResult, TextWriter output
         outputWriter.Write(result.AsSpan());
         outputWriter.Flush();
         var commandString = CommandHierarchyAsString(commandResult);
-        var telemetryProperties = new Dictionary<string, string> { { "command", commandString } };
+        var telemetryProperties = new Dictionary<string, string?> { { "command", commandString } };
         telemetryClient?.TrackEvent("schema", telemetryProperties, null);
     }
 
diff --git a/src/Cli/dotnet/CommandDirectoryContext.cs b/src/Cli/dotnet/CommandDirectoryContext.cs
index c6ee09033687..c778a3bfd1a1 100644
--- a/src/Cli/dotnet/CommandDirectoryContext.cs
+++ b/src/Cli/dotnet/CommandDirectoryContext.cs
@@ -35,7 +35,7 @@ public static void PerformActionWithBasePath(string basePath, Action action)
                 $"Calls to {nameof(CommandDirectoryContext)}.{nameof(PerformActionWithBasePath)} cannot be nested.");
         }
         _basePath = basePath;
-        Telemetry.Telemetry.CurrentSessionId = null;
+        Telemetry.Telemetry.s_currentSessionId = null;
         try
         {
             action();
diff --git a/src/Cli/dotnet/CommandFactory/CommandResolution/ActivityContext.cs b/src/Cli/dotnet/CommandFactory/CommandResolution/ActivityContext.cs
new file mode 100644
index 000000000000..697bdadef375
--- /dev/null
+++ b/src/Cli/dotnet/CommandFactory/CommandResolution/ActivityContext.cs
@@ -0,0 +1,42 @@
+
+using System.Diagnostics;
+using Microsoft.DotNet.Cli.Utils;
+using OpenTelemetry;
+using OpenTelemetry.Context.Propagation;
+
+namespace Microsoft.DotNet.Cli.CommandFactory.CommandResolution;
+
+public static class ActivityContext
+{
+    public static Dictionary<string, string>? MakeActivityContextEnvironment()
+    {
+        var currentActivity = Activity.Current;
+        var currentBaggage = Baggage.Current;
+        if (currentActivity == null)
+        {
+            return null;
+        }
+        var contextToInject = currentActivity.Context;
+        if (contextToInject.TraceId == default && contextToInject.SpanId == default && contextToInject.TraceState is null)
+        {
+            return null;
+        }
+        var propagationContext = new PropagationContext(contextToInject, currentBaggage);
+        var envDict = new Dictionary<string, string>(capacity: 2);
+        Propagators.DefaultTextMapPropagator.Inject(propagationContext, envDict, WriteTraceStateIntoEnv);
+        return envDict;
+    }
+
+    private static void WriteTraceStateIntoEnv(Dictionary<string, string> dictionary, string key, string value)
+    {
+        switch (key)
+        {
+            case "traceparent":
+                dictionary[Activities.TRACEPARENT] = value;
+                break;
+            case "tracestate":
+                dictionary[Activities.TRACESTATE] = value;
+                break;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Cli/dotnet/CommandFactory/CommandResolution/MuxerCommandResolver.cs b/src/Cli/dotnet/CommandFactory/CommandResolution/MuxerCommandResolver.cs
index 1998ae144809..6f79441cd220 100644
--- a/src/Cli/dotnet/CommandFactory/CommandResolution/MuxerCommandResolver.cs
+++ b/src/Cli/dotnet/CommandFactory/CommandResolution/MuxerCommandResolver.cs
@@ -1,8 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.Cli.Utils.Extensions;
 
@@ -10,14 +8,15 @@ namespace Microsoft.DotNet.Cli.CommandFactory.CommandResolution;
 
 public class MuxerCommandResolver : ICommandResolver
 {
-    public CommandSpec Resolve(CommandResolverArguments commandResolverArguments)
+    public CommandSpec? Resolve(CommandResolverArguments commandResolverArguments)
     {
         if (commandResolverArguments.CommandName == Muxer.MuxerName)
         {
             var muxer = new Muxer();
             var escapedArgs = ArgumentEscaper.EscapeAndConcatenateArgArrayForProcessStart(
                 commandResolverArguments.CommandArguments.OrEmptyIfNull());
-            return new CommandSpec(muxer.MuxerPath, escapedArgs);
+            var env = ActivityContext.MakeActivityContextEnvironment();
+            return new CommandSpec(muxer.MuxerPath, escapedArgs, env);
         }
         return null;
     }
diff --git a/src/Cli/dotnet/CommandFactory/CommandResolution/MuxerCommandSpecMaker.cs b/src/Cli/dotnet/CommandFactory/CommandResolution/MuxerCommandSpecMaker.cs
index 63a3ecae1d5b..af9cddebf5d5 100644
--- a/src/Cli/dotnet/CommandFactory/CommandResolution/MuxerCommandSpecMaker.cs
+++ b/src/Cli/dotnet/CommandFactory/CommandResolution/MuxerCommandSpecMaker.cs
@@ -1,8 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using Microsoft.DotNet.Cli.Utils;
 
 namespace Microsoft.DotNet.Cli.CommandFactory.CommandResolution;
@@ -11,7 +9,8 @@ internal static class MuxerCommandSpecMaker
 {
     internal static CommandSpec CreatePackageCommandSpecUsingMuxer(
         string commandPath,
-        IEnumerable<string> commandArguments)
+        IEnumerable<string>? commandArguments,
+        IDictionary<string, string>? env = null)
     {
         var arguments = new List<string>();
 
@@ -45,15 +44,16 @@ internal static CommandSpec CreatePackageCommandSpecUsingMuxer(
                 arguments.AddRange(commandArguments);
             }
         }
-        return CreateCommandSpec(host, arguments);
+        return CreateCommandSpec(host, arguments, env);
     }
 
     private static CommandSpec CreateCommandSpec(
         string commandPath,
-        IEnumerable<string> commandArguments)
+        IEnumerable<string>? commandArguments,
+        IDictionary<string, string>? env = null)
     {
-        var escapedArgs = ArgumentEscaper.EscapeAndConcatenateArgArrayForProcessStart(commandArguments);
+        var escapedArgs = commandArguments is not null ? ArgumentEscaper.EscapeAndConcatenateArgArrayForProcessStart(commandArguments) : null;
 
-        return new CommandSpec(commandPath, escapedArgs);
+        return new CommandSpec(commandPath, escapedArgs, env);
     }
 }
diff --git a/src/Cli/dotnet/CommandFactory/CommandSpec.cs b/src/Cli/dotnet/CommandFactory/CommandSpec.cs
index 6af14dd0b931..b6afa94bcc5c 100644
--- a/src/Cli/dotnet/CommandFactory/CommandSpec.cs
+++ b/src/Cli/dotnet/CommandFactory/CommandSpec.cs
@@ -8,13 +8,13 @@ namespace Microsoft.DotNet.Cli.CommandFactory;
 public class CommandSpec(
     string path,
     string? args,
-    Dictionary<string, string>? environmentVariables = null)
+    IDictionary<string, string>? environmentVariables = null)
 {
     public string Path { get; } = path;
 
     public string? Args { get; } = args;
 
-    public Dictionary<string, string> EnvironmentVariables { get; } = environmentVariables ?? [];
+    public IDictionary<string, string> EnvironmentVariables { get; } = environmentVariables ?? new Dictionary<string, string>();
 
     internal void AddEnvironmentVariablesFromProject(IProject project)
     {
diff --git a/src/Cli/dotnet/Commands/Hidden/InternalReportInstallSuccess/InternalReportInstallSuccessCommand.cs b/src/Cli/dotnet/Commands/Hidden/InternalReportInstallSuccess/InternalReportInstallSuccessCommand.cs
index 744289023948..e3478d60eb4a 100644
--- a/src/Cli/dotnet/Commands/Hidden/InternalReportInstallSuccess/InternalReportInstallSuccessCommand.cs
+++ b/src/Cli/dotnet/Commands/Hidden/InternalReportInstallSuccess/InternalReportInstallSuccessCommand.cs
@@ -1,13 +1,10 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System.CommandLine;
 using Microsoft.DotNet.Cli.Extensions;
 using Microsoft.DotNet.Cli.Telemetry;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.Configurer;
 
 namespace Microsoft.DotNet.Cli.Commands.Hidden.InternalReportInstallSuccess;
 
@@ -19,7 +16,6 @@ public static int Run(ParseResult parseResult)
     {
         var telemetry = new ThreadBlockingTelemetry();
         ProcessInputAndSendTelemetry(parseResult, telemetry);
-        telemetry.Dispose();
         return 0;
     }
 
@@ -42,33 +38,24 @@ public static void ProcessInputAndSendTelemetry(ParseResult result, ITelemetry t
 
     internal class ThreadBlockingTelemetry : ITelemetry
     {
-        private readonly Telemetry.Telemetry telemetry;
+        private readonly Telemetry.Telemetry _telemetry;
 
         internal ThreadBlockingTelemetry()
         {
-            var sessionId =
-            Environment.GetEnvironmentVariable(TelemetrySessionIdEnvironmentVariableName);
-            telemetry = new Telemetry.Telemetry(new NoOpFirstTimeUseNoticeSentinel(), sessionId, blockThreadInitialization: true);
-        }
-        public bool Enabled => telemetry.Enabled;
-
-        public void Flush()
-        {
+            var sessionId = Environment.GetEnvironmentVariable(TelemetrySessionIdEnvironmentVariableName);
+            _telemetry = new Telemetry.Telemetry(sessionId);
         }
 
-        public void Dispose()
-        {
-            telemetry.Dispose();
-        }
+        public bool Enabled => _telemetry.Enabled;
 
-        public void TrackEvent(string eventName, IDictionary<string, string> properties, IDictionary<string, double> measurements)
+        public void TrackEvent(string eventName, IDictionary<string, string?>? properties, IDictionary<string, double>? measurements)
         {
-            telemetry.ThreadBlockingTrackEvent(eventName, properties, measurements);
+            _telemetry.ThreadBlockingTrackEvent(eventName, properties, measurements);
         }
     }
 }
 
-internal class InstallerSuccessReport(string exeName)
+internal class InstallerSuccessReport(string? exeName)
 {
     public string ExeName { get; } = exeName ?? throw new ArgumentNullException(nameof(exeName));
 }
diff --git a/src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingApp.cs b/src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingApp.cs
index 3055de0883f5..da80aaa99d46 100644
--- a/src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingApp.cs
+++ b/src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingApp.cs
@@ -20,7 +20,7 @@ public class MSBuildForwardingApp : CommandBase
     /// </summary>
     private static MSBuildArgs ConcatTelemetryLogger(MSBuildArgs msbuildArgs)
     {
-        if (Telemetry.Telemetry.CurrentSessionId != null)
+        if (Telemetry.Telemetry.s_currentSessionId != null)
         {
             try
             {
@@ -78,7 +78,7 @@ public ProcessStartInfo GetProcessStartInfo()
 
     private void InitializeRequiredEnvironmentVariables()
     {
-        EnvironmentVariable(TelemetrySessionIdEnvironmentVariableName, Telemetry.Telemetry.CurrentSessionId);
+        EnvironmentVariable(TelemetrySessionIdEnvironmentVariableName, Telemetry.Telemetry.s_currentSessionId);
     }
 
     /// <summary>
diff --git a/src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingLogger.cs b/src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingLogger.cs
index fef3e251bedc..85ecf68dcaf4 100644
--- a/src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingLogger.cs
+++ b/src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingLogger.cs
@@ -26,7 +26,7 @@ public void Initialize(IEventSource eventSource)
             eventSource4.IncludeEvaluationPropertiesAndItems();
         }
 
-        // Forward telemetry events
+        // Only forward telemetry events
         if (eventSource is IEventSource2 eventSource2)
         {
             eventSource2.TelemetryLogged += (sender, args) => BuildEventRedirector.ForwardEvent(args);
diff --git a/src/Cli/dotnet/Commands/MSBuild/MSBuildLogger.cs b/src/Cli/dotnet/Commands/MSBuild/MSBuildLogger.cs
index 2656f9798a9e..c7cf7baa6217 100644
--- a/src/Cli/dotnet/Commands/MSBuild/MSBuildLogger.cs
+++ b/src/Cli/dotnet/Commands/MSBuild/MSBuildLogger.cs
@@ -5,14 +5,11 @@
 using Microsoft.Build.Framework;
 using Microsoft.DotNet.Cli.Telemetry;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.Configurer;
 
 namespace Microsoft.DotNet.Cli.Commands.MSBuild;
 
 public sealed class MSBuildLogger : INodeLogger
 {
-    private readonly IFirstTimeUseNoticeSentinel _sentinel =
-        new FirstTimeUseNoticeSentinel();
     private readonly ITelemetry? _telemetry;
 
     internal const string TargetFrameworkTelemetryEventName = "targetframeworkeval";
@@ -65,19 +62,11 @@ public MSBuildLogger()
     {
         try
         {
-            string? sessionId =
-                Environment.GetEnvironmentVariable(MSBuildForwardingApp.TelemetrySessionIdEnvironmentVariableName);
+            string? sessionId = Environment.GetEnvironmentVariable(MSBuildForwardingApp.TelemetrySessionIdEnvironmentVariableName);
 
             if (sessionId != null)
             {
-                // senderCount: 0 to disable sender.
-                // When senders in different process running at the same
-                // time they will read from the same global queue and cause
-                // sending duplicated events. Disable sender to reduce it.
-                _telemetry = new Telemetry.Telemetry(
-                    _sentinel,
-                    sessionId,
-                    senderCount: 0);
+                _telemetry = new Telemetry.Telemetry(sessionId);
             }
         }
         catch (Exception)
@@ -253,7 +242,7 @@ private static void TrackEvent(ITelemetry? telemetry, string eventName, IDiction
         {
             foreach (var propertyToBeHashed in toBeHashed)
             {
-                if (eventProperties.TryGetValue(propertyToBeHashed, out var value))
+                if (eventProperties.TryGetValue(propertyToBeHashed, out var value) && value is not null)
                 {
                     // Lets lazy allocate in case there is tons of telemetry
                     properties ??= new(eventProperties);
@@ -281,7 +270,7 @@ private static void TrackEvent(ITelemetry? telemetry, string eventName, IDiction
             }
         }
 
-        telemetry.TrackEvent(eventName, properties ?? eventProperties, measurements);
+        telemetry?.TrackEvent(eventName, properties ?? eventProperties, measurements);
     }
 
     private void OnTelemetryLogged(object sender, TelemetryEventArgs args)
@@ -298,14 +287,6 @@ private void OnTelemetryLogged(object sender, TelemetryEventArgs args)
 
     public void Shutdown()
     {
-        try
-        {
-            _sentinel?.Dispose();
-        }
-        catch (Exception)
-        {
-            // Exceptions during telemetry shouldn't cause anything else to fail
-        }
     }
 
     public LoggerVerbosity Verbosity { get; set; }
diff --git a/src/Cli/dotnet/Commands/New/BuiltInTemplatePackageProvider.cs b/src/Cli/dotnet/Commands/New/BuiltInTemplatePackageProvider.cs
index ceb8471b820c..0979199a5668 100644
--- a/src/Cli/dotnet/Commands/New/BuiltInTemplatePackageProvider.cs
+++ b/src/Cli/dotnet/Commands/New/BuiltInTemplatePackageProvider.cs
@@ -1,8 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
+using Microsoft.DotNet.Cli.Utils;
 using Microsoft.TemplateEngine.Abstractions;
 using Microsoft.TemplateEngine.Abstractions.TemplatePackage;
 using NuGet.Versioning;
@@ -18,14 +17,16 @@ internal sealed class BuiltInTemplatePackageProvider(BuiltInTemplatePackageProvi
 
     public ITemplatePackageProviderFactory Factory { get; } = factory;
 
-#pragma warning disable CS0067
     /// <summary>
     /// We don't trigger this event, we could complicate our life with FileSystemWatcher.
-    /// But since "dotnet new" is short lived process is not worth it, plus it would cause
-    /// some perf hit...
+    /// But since "dotnet new" is short lived process is not worth it, plus it would cause some perf hit...
+    /// To avoid warnings about being unused, implement empty add/remove accessors.
     /// </summary>
-    public event Action TemplatePackagesChanged;
-#pragma warning restore CS0067
+    public event Action? TemplatePackagesChanged
+    {
+        add { }
+        remove { }
+    }
 
     public Task<IReadOnlyList<ITemplatePackage>> GetAllTemplatePackagesAsync(CancellationToken cancellationToken)
     {
@@ -44,11 +45,12 @@ private static IEnumerable<string> GetTemplateFolders(IEngineEnvironmentSettings
     {
         var templateFoldersToInstall = new List<string>();
 
-        var sdkDirectory = Path.GetDirectoryName(typeof(Utils.DotnetFiles).Assembly.Location);
-        var dotnetRootPath = Path.GetDirectoryName(Path.GetDirectoryName(sdkDirectory));
-
+        var sdksDirectory = new DirectoryInfo(MSBuildForwardingAppWithoutLogging.GetMSBuildSDKsPath());
+        var sdkDirectory = sdksDirectory.Parent!;
+        var sdkVersion = sdkDirectory.Name;
+        var dotnetRootPath = sdkDirectory.Parent!.Parent!;
         // First grab templates from dotnet\templates\M.m folders, in ascending order, up to our version
-        string templatesRootFolder = Path.GetFullPath(Path.Combine(dotnetRootPath, "templates"));
+        string templatesRootFolder = Path.Combine(dotnetRootPath.FullName, "templates");
         if (Directory.Exists(templatesRootFolder))
         {
             IReadOnlyDictionary<string, SemanticVersion> parsedNames = GetVersionDirectoriesInDirectory(templatesRootFolder);
@@ -59,7 +61,7 @@ private static IEnumerable<string> GetTemplateFolders(IEngineEnvironmentSettings
         }
 
         // Now grab templates from our base folder, if present.
-        string templatesDir = Path.Combine(sdkDirectory, "Templates");
+        string templatesDir = Path.Combine(sdkDirectory.FullName, "Templates");
         if (Directory.Exists(templatesDir))
         {
             templateFoldersToInstall.Add(templatesDir);
@@ -76,7 +78,7 @@ private static IReadOnlyDictionary<string, SemanticVersion> GetVersionDirectorie
 
         foreach (string directory in Directory.EnumerateDirectories(fullPath, "*.*", SearchOption.TopDirectoryOnly))
         {
-            if (SemanticVersion.TryParse(Path.GetFileName(directory), out SemanticVersion versionInfo))
+            if (SemanticVersion.TryParse(Path.GetFileName(directory), out SemanticVersion? versionInfo) && versionInfo is not null)
             {
                 versionFileInfo.Add(directory, versionInfo);
             }
@@ -89,7 +91,7 @@ private static IList<string> GetBestVersionsByMajorMinor(IReadOnlyDictionary<str
     {
         IDictionary<string, (string path, SemanticVersion version)> bestVersionsByBucket = new Dictionary<string, (string path, SemanticVersion version)>();
 
-        Version sdkVersion = typeof(NewCommandParser).Assembly.GetName().Version;
+        Version? sdkVersion = typeof(NewCommandParser).Assembly.GetName().Version;
         foreach (KeyValuePair<string, SemanticVersion> dirInfo in versionDirInfo)
         {
             var majorMinorDirVersion = new Version(dirInfo.Value.Major, dirInfo.Value.Minor);
diff --git a/src/Cli/dotnet/Commands/New/OptionalWorkloadProvider.cs b/src/Cli/dotnet/Commands/New/OptionalWorkloadProvider.cs
index a2a14b6033e2..77e48fe7b32a 100644
--- a/src/Cli/dotnet/Commands/New/OptionalWorkloadProvider.cs
+++ b/src/Cli/dotnet/Commands/New/OptionalWorkloadProvider.cs
@@ -1,8 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.Configurer;
 using Microsoft.TemplateEngine.Abstractions;
@@ -22,8 +20,8 @@ internal OptionalWorkloadProvider(ITemplatePackageProviderFactory factory, IEngi
 
     public ITemplatePackageProviderFactory Factory { get; }
 
-    // To avoid warnings about unused, its implemented via add/remove
-    event Action ITemplatePackageProvider.TemplatePackagesChanged
+    // To avoid warnings about being unused, implement empty add/remove accessors.
+    event Action? ITemplatePackageProvider.TemplatePackagesChanged
     {
         add { }
         remove { }
@@ -33,12 +31,13 @@ public Task<IReadOnlyList<ITemplatePackage>> GetAllTemplatePackagesAsync(Cancell
     {
         var list = new List<TemplatePackage>();
         var optionalWorkloadLocator = new TemplateLocator.TemplateLocator();
-        var sdkDirectory = Path.GetDirectoryName(typeof(DotnetFiles).Assembly.Location);
-        var sdkVersion = Path.GetFileName(sdkDirectory);
-        var dotnetRootPath = Path.GetDirectoryName(Path.GetDirectoryName(sdkDirectory));
+        var sdksDirectory = new DirectoryInfo(MSBuildForwardingAppWithoutLogging.GetMSBuildSDKsPath());
+        var sdkDirectory = sdksDirectory?.Parent;
+        var sdkVersion = sdkDirectory?.Name;
+        var dotnetRootPath = sdkDirectory?.Parent?.Parent;
         string userProfileDir = CliFolderPathCalculator.DotnetUserProfileFolderPath;
 
-        var packages = optionalWorkloadLocator.GetDotnetSdkTemplatePackages(sdkVersion, dotnetRootPath, userProfileDir);
+        var packages = optionalWorkloadLocator.GetDotnetSdkTemplatePackages(sdkVersion, dotnetRootPath?.FullName, userProfileDir);
         var fileSystem = _environmentSettings.Host.FileSystem;
         foreach (var packageInfo in packages)
         {
diff --git a/src/Cli/dotnet/Commands/Tool/ToolCommandSpecCreator.cs b/src/Cli/dotnet/Commands/Tool/ToolCommandSpecCreator.cs
index f043eafc93be..8269e3c84bdc 100644
--- a/src/Cli/dotnet/Commands/Tool/ToolCommandSpecCreator.cs
+++ b/src/Cli/dotnet/Commands/Tool/ToolCommandSpecCreator.cs
@@ -11,6 +11,7 @@ internal class ToolCommandSpecCreator
 {
     public static CommandSpec CreateToolCommandSpec(string toolName, string toolExecutable, string toolRunner, bool allowRollForward, IEnumerable<string> commandArguments)
     {
+        var env = ActivityContext.MakeActivityContextEnvironment();
         if (toolRunner == "dotnet")
         {
             if (allowRollForward)
@@ -20,7 +21,8 @@ public static CommandSpec CreateToolCommandSpec(string toolName, string toolExec
 
             return MuxerCommandSpecMaker.CreatePackageCommandSpecUsingMuxer(
                 toolExecutable,
-                commandArguments);
+                commandArguments,
+                env);
         }
         else if (toolRunner == "executable")
         {
@@ -29,7 +31,8 @@ public static CommandSpec CreateToolCommandSpec(string toolName, string toolExec
 
             return new CommandSpec(
                 toolExecutable,
-                escapedArgs);
+                escapedArgs,
+                env);
         }
         else
         {
diff --git a/src/Cli/dotnet/CommonOptionsFactory.cs b/src/Cli/dotnet/CommonOptionsFactory.cs
index f776cd47712a..fa9dc531eb83 100644
--- a/src/Cli/dotnet/CommonOptionsFactory.cs
+++ b/src/Cli/dotnet/CommonOptionsFactory.cs
@@ -1,9 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System.CommandLine;
+using System.CommandLine.Invocation;
+using Microsoft.DotNet.Cli.Utils;
 
 namespace Microsoft.DotNet.Cli;
 
@@ -19,6 +19,22 @@ internal static class CommonOptionsFactory
     {
         Description = CliStrings.SDKDiagnosticsCommandDefinition,
         Recursive = recursive,
-        Arity = ArgumentArity.Zero
+        Arity = ArgumentArity.Zero,
+        Action = new SetDiagnosticModeAction()
     };
+
+    /// <summary>
+    /// Sets a few verbose diagnostics flags across the CLI.
+    /// Other commands may also use this to set their verbosity flags to a higher value or similar behaviors.
+    /// </summary>
+    internal class SetDiagnosticModeAction() : SynchronousCommandLineAction
+    {
+        public override int Invoke(ParseResult parseResult)
+        {
+            Environment.SetEnvironmentVariable(CommandLoggingContext.Variables.Verbose, bool.TrueString);
+            CommandLoggingContext.SetVerbose(true);
+            Reporter.Reset();
+            return 0;
+        }
+    }
 }
diff --git a/src/Cli/dotnet/Extensions/ParseResultExtensions.cs b/src/Cli/dotnet/Extensions/ParseResultExtensions.cs
index 6bcf5f84ff8c..06775ddc5c5b 100644
--- a/src/Cli/dotnet/Extensions/ParseResultExtensions.cs
+++ b/src/Cli/dotnet/Extensions/ParseResultExtensions.cs
@@ -15,17 +15,17 @@ namespace Microsoft.DotNet.Cli.Extensions;
 
 public static class ParseResultExtensions
 {
-    ///<summary>
+    /// <summary>
     /// Finds the command of the parse result and invokes help for that command.
     /// If no command is specified, invokes help for the application.
-    ///<summary>
-    ///<remarks>
+    /// <summary>
+    /// <remarks>
     /// This is accomplished by finding a set of tokens that should be valid and appending a help token
     /// to that list, then re-parsing the list of tokens. This is not ideal - either we should have a direct way
     /// of invoking help for a ParseResult, or we should eliminate this custom, ad-hoc help invocation by moving
     /// more situations that want to show help into Parsing Errors (which trigger help in the default System.CommandLine pipeline)
     /// or custom Invocation Middleware, so we can more easily create our version of a HelpResult type.
-    ///</remarks>
+    /// </remarks>
     public static void ShowHelp(this ParseResult parseResult)
     {
         // take from the start of the list until we hit an option/--/unparsed token
@@ -56,14 +56,17 @@ public static void ShowHelpOrErrorIfAppropriate(this ParseResult parseResult)
             }
         }
 
-        ///<summary>Splits a .NET format string by the format placeholders (the {N} parts) to get an array of the literal parts, to be used in message-checking</summary>
+        /// <summary>
+        /// Splits a .NET format string by the format placeholders (the {N} parts) to get an array of the literal parts, to be used in message-checking.
+        /// </summary>
         static string[] DistinctFormatStringParts(string formatString)
         {
             return Regex.Split(formatString, @"{[0-9]+}"); // match the literal '{', followed by any of 0-9 one or more times, followed by the literal '}'
         }
 
-
-        /// <summary>given a string and a series of parts, ensures that all parts are present in the string in sequential order</summary>
+        /// <summary>
+        /// Given a string and a series of parts, ensures that all parts are present in the string in sequential order.
+        /// </summary>
         static bool ErrorContainsAllParts(ReadOnlySpan<char> error, string[] parts)
         {
             foreach (var part in parts)
@@ -85,9 +88,12 @@ static bool ErrorContainsAllParts(ReadOnlySpan<char> error, string[] parts)
 
     public static string RootSubCommandResult(this ParseResult parseResult)
     {
-        return parseResult.RootCommandResult.Children?
-            .Select(child => GetSymbolResultValue(parseResult, child))
-            .FirstOrDefault(subcommand => !string.IsNullOrEmpty(subcommand)) ?? string.Empty;
+        CommandResult commandResult = parseResult.CommandResult;
+        while (commandResult != parseResult.RootCommandResult && commandResult.Parent is CommandResult parentCommand)
+        {
+            commandResult = parentCommand;
+        }
+        return commandResult.Command.Name;
     }
 
     public static bool IsDotnetBuiltInCommand(this ParseResult parseResult)
@@ -101,12 +107,7 @@ public static bool IsTopLevelDotnetCommand(this ParseResult parseResult)
         return parseResult.CommandResult.Command.Equals(Parser.RootCommand) && string.IsNullOrEmpty(parseResult.RootSubCommandResult());
     }
 
-    public static bool CanBeInvoked(this ParseResult parseResult)
-    {
-        return Parser.GetBuiltInCommand(parseResult.RootSubCommandResult()) != null ||
-            parseResult.Tokens.Any(token => token.Type == TokenType.Directive) ||
-            (parseResult.IsTopLevelDotnetCommand() && string.IsNullOrEmpty(parseResult.GetValue(Parser.DotnetSubCommand)));
-    }
+    public static bool CanBeInvoked(this ParseResult parseResult) => parseResult.Action is not null;
 
     public static int HandleMissingCommand(this ParseResult parseResult)
     {
@@ -163,13 +164,6 @@ public static bool DiagOptionPrecedesSubcommand(this string[] args, string subCo
         return false;
     }
 
-    private static string? GetSymbolResultValue(ParseResult parseResult, SymbolResult symbolResult) => symbolResult switch
-    {
-        CommandResult commandResult => commandResult.Command.Name,
-        ArgumentResult argResult => argResult.Tokens.FirstOrDefault()?.Value,
-        _ => parseResult.GetResult(Parser.DotnetSubCommand)?.GetValueOrDefault<string>()
-    };
-
     public static bool BothArchAndOsOptionsSpecified(this ParseResult parseResult) =>
         (parseResult.HasOption(CommonOptions.ArchitectureOption) ||
         parseResult.HasOption(CommonOptions.LongFormArchitectureOption)) &&
@@ -177,7 +171,7 @@ public static bool BothArchAndOsOptionsSpecified(this ParseResult parseResult) =
 
     public static bool UsingRunCommandShorthandProjectOption(this ParseResult parseResult)
     {
-        if (parseResult.HasOption(RunCommandParser.PropertyOption) && parseResult.GetValue(RunCommandParser.PropertyOption)!.Any())
+        if (parseResult.HasOption(RunCommandParser.PropertyOption) && (parseResult.GetValue(RunCommandParser.PropertyOption)?.Any() ?? false))
         {
             var projVals = parseResult.GetRunCommandShorthandProjectValues();
             if (projVals?.Any() is true)
diff --git a/src/Cli/dotnet/Parser.cs b/src/Cli/dotnet/Parser.cs
index 23dd3d6ebef3..aacf083f6af3 100644
--- a/src/Cli/dotnet/Parser.cs
+++ b/src/Cli/dotnet/Parser.cs
@@ -1,8 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System.CommandLine;
 using System.CommandLine.Completions;
 using System.CommandLine.Invocation;
@@ -96,14 +94,38 @@ public static class Parser
 
     public static readonly Option<bool> VersionOption = new("--version")
     {
-        Arity = ArgumentArity.Zero
+        Arity = ArgumentArity.Zero,
+        Action = new PrintVersionAction()
     };
 
+    internal class PrintVersionAction : SynchronousCommandLineAction
+    {
+        public override bool Terminating => true;
+
+        public override int Invoke(ParseResult parseResult)
+        {
+            CommandLineInfo.PrintVersion();
+            return 0;
+        }
+    }
+
     public static readonly Option<bool> InfoOption = new("--info")
     {
-        Arity = ArgumentArity.Zero
+        Arity = ArgumentArity.Zero,
+        Action = new PrintInfoAction()
     };
 
+    internal class PrintInfoAction : SynchronousCommandLineAction
+    {
+        public override bool Terminating => true;
+
+        public override int Invoke(ParseResult parseResult)
+        {
+            CommandLineInfo.PrintInfo();
+            return 0;
+        }
+    }
+
     public static readonly Option<bool> ListSdksOption = new("--list-sdks")
     {
         Arity = ArgumentArity.Zero
@@ -169,31 +191,22 @@ private static RootCommand ConfigureCommandLine(RootCommand rootCommand)
 
         rootCommand.SetAction(parseResult =>
         {
-            if (parseResult.GetValue(DiagOption) && parseResult.Tokens.Count == 1)
-            {
-                // when user does not specify any args except of diagnostics ("dotnet -d"), we do nothing
-                // as Program.ProcessArgs already enabled the diagnostic output
-                return 0;
-            }
-            else
-            {
-                // when user does not specify any args (just "dotnet"), a usage needs to be printed
-                parseResult.InvocationConfiguration.Output.WriteLine(CliUsage.HelpText);
-                return 0;
-            }
+            // when user does not specify any args (just "dotnet"), a usage needs to be printed
+            parseResult.InvocationConfiguration.Output.WriteLine(CliUsage.HelpText);
+            return 0;
         });
 
         return rootCommand;
     }
 
-    public static Command GetBuiltInCommand(string commandName) =>
+    public static Command? GetBuiltInCommand(string commandName) =>
         Subcommands.FirstOrDefault(c => c.Name.Equals(commandName, StringComparison.OrdinalIgnoreCase));
 
     /// <summary>
     /// Implements token-per-line response file handling for the CLI. We use this instead of the built-in S.CL handling
     /// to ensure backwards-compatibility with MSBuild.
     /// </summary>
-    public static bool TokenPerLine(string tokenToReplace, out IReadOnlyList<string> replacementTokens, out string errorMessage)
+    public static bool TokenPerLine(string tokenToReplace, out IReadOnlyList<string>? replacementTokens, out string? errorMessage)
     {
         var filePath = Path.GetFullPath(tokenToReplace);
         if (File.Exists(filePath))
@@ -256,8 +269,7 @@ public static bool TokenPerLine(string tokenToReplace, out IReadOnlyList<string>
     public static int Invoke(string[] args) => Invoke(Parse(args));
     public static Task<int> InvokeAsync(string[] args, CancellationToken cancellationToken = default) => InvokeAsync(Parse(args), cancellationToken);
 
-
-    internal static int ExceptionHandler(Exception exception, ParseResult parseResult)
+    internal static int ExceptionHandler(Exception? exception, ParseResult parseResult)
     {
         if (exception is TargetInvocationException)
         {
@@ -277,13 +289,13 @@ internal static int ExceptionHandler(Exception exception, ParseResult parseResul
                 exception.Message.Red().Bold());
             parseResult.ShowHelp();
         }
-        else if (exception.GetType().Name.Equals("WorkloadManifestCompositionException"))
+        else if (exception is not null && exception.GetType().Name.Equals("WorkloadManifestCompositionException"))
         {
             Reporter.Error.WriteLine(CommandLoggingContext.IsVerbose ?
                 exception.ToString().Red().Bold() :
                 exception.Message.Red().Bold());
         }
-        else
+        else if (exception is not null)
         {
             Reporter.Error.Write("Unhandled exception: ".Red().Bold());
             Reporter.Error.WriteLine(CommandLoggingContext.IsVerbose ?
@@ -371,7 +383,7 @@ public override void Write(HelpContext context)
             }
             else if (command.Name.Equals(FormatCommandParser.GetCommand().Name))
             {
-                var arguments = context.ParseResult.GetValue(FormatCommandParser.Arguments);
+                var arguments = context.ParseResult.GetValue(FormatCommandParser.Arguments) ?? [];
                 new FormatForwardingApp([.. arguments, .. helpArgs]).Execute();
             }
             else if (command.Name.Equals(FsiCommandParser.GetCommand().Name))
@@ -398,9 +410,9 @@ public override void Write(HelpContext context)
             {
                 if (command.Name.Equals(ListReferenceCommandParser.GetCommand().Name))
                 {
-                    Command listCommand = command.Parents.Single() as Command;
+                    Command? listCommand = command.Parents.Single() as Command;
 
-                    for (int i = 0; i < listCommand.Arguments.Count; i++)
+                    for (int i = 0; i < listCommand?.Arguments.Count; i++)
                     {
                         if (listCommand.Arguments[i].Name == CliStrings.SolutionOrProjectArgumentName)
                         {
diff --git a/src/Cli/dotnet/Program.cs b/src/Cli/dotnet/Program.cs
index 71feefd8e7f9..0b1b71772613 100644
--- a/src/Cli/dotnet/Program.cs
+++ b/src/Cli/dotnet/Program.cs
@@ -1,8 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
+using Azure.Monitor.OpenTelemetry.Exporter;
 using System.CommandLine;
 using System.CommandLine.Parsing;
 using System.Diagnostics;
@@ -20,22 +19,87 @@
 using Microsoft.DotNet.Configurer;
 using Microsoft.Extensions.EnvironmentAbstractions;
 using NuGet.Frameworks;
+using OpenTelemetry;
+using OpenTelemetry.Context.Propagation;
+using OpenTelemetry.Metrics;
+using OpenTelemetry.Resources;
+using OpenTelemetry.Trace;
 using CommandResult = System.CommandLine.Parsing.CommandResult;
 
 namespace Microsoft.DotNet.Cli;
 
 public class Program
 {
-    private static readonly string ToolPathSentinelFileName = $"{Product.Version}.toolpath.sentinel";
+    private static readonly string s_toolPathSentinelFileName = $"{Product.Version}.toolpath.sentinel";
+
+    public static readonly ITelemetry TelemetryClient;
+
+    // Create a new OpenTelemetry tracer provider and add the Azure Monitor trace exporter and the OTLP trace exporter.
+    // It is important to keep the TracerProvider instance active throughout the process lifetime.
+    private static readonly TracerProvider s_tracerProvider;
+
+    // Create a new OpenTelemetry meter provider and add the Azure Monitor metric exporter and the OTLP metric exporter.
+    // It is important to keep the MetricsProvider instance active throughout the process lifetime.
+    private static readonly MeterProvider s_metricsProvider;
+
+    private static readonly Activity? s_mainActivity;
+    private static readonly DateTime s_mainTimeStamp;
+    private static readonly PosixSignalRegistration s_sigIntRegistration;
+    private static readonly PosixSignalRegistration s_sigQuitRegistration;
+    private static readonly PosixSignalRegistration s_sigTermRegistration;
+
+    static Program()
+    {
+        s_mainTimeStamp = DateTime.Now;
+        s_sigIntRegistration = PosixSignalRegistration.Create(PosixSignal.SIGINT, Shutdown);
+        s_sigQuitRegistration = PosixSignalRegistration.Create(PosixSignal.SIGQUIT, Shutdown);
+        s_sigTermRegistration = PosixSignalRegistration.Create(PosixSignal.SIGTERM, Shutdown);
+        s_metricsProvider = Sdk.CreateMeterProviderBuilder()
+            .ConfigureResource(r =>
+            {
+                r.AddService("dotnet-cli", serviceVersion: Product.Version);
+            })
+            .AddMeter(Activities.Source.Name)
+            .AddHttpClientInstrumentation()
+            .AddRuntimeInstrumentation()
+            .AddOtlpExporter()
+            .Build();
+
+        s_tracerProvider = Sdk.CreateTracerProviderBuilder()
+            .ConfigureResource(r =>
+            {
+                r.AddService("dotnet-cli", serviceVersion: Product.Version);
+            })
+            .AddSource(Activities.Source.Name)
+            .AddHttpClientInstrumentation()
+            .AddOtlpExporter()
+            .AddAzureMonitorTraceExporter(o =>
+            {
+                o.ConnectionString = Telemetry.Telemetry.ConnectionString;
+                o.EnableLiveMetrics = false;
+                o.StorageDirectory = Path.Combine(CliFolderPathCalculator.DotnetUserProfileFolderPath, Telemetry.Telemetry.DefaultStorageFolderName);
+            })
+            .SetSampler(new AlwaysOnSampler())
+            .Build();
+
+        (var s_parentActivityContext, var s_activityKind) = DeriveParentActivityContextFromEnv();
+        s_mainActivity = Activities.Source.CreateActivity("main", s_activityKind, s_parentActivityContext);
+        s_mainActivity?.Start();
+        s_mainActivity?.SetStartTime(Process.GetCurrentProcess().StartTime);
+        s_mainActivity?.AddTag("process.pid", Process.GetCurrentProcess().Id);
+        s_mainActivity?.AddTag("process.executable.name", "dotnet");
+        TelemetryClient = InitializeTelemetry();
+        TrackHostStartup(TelemetryClient, s_mainTimeStamp);
+        SetupMSBuildEnvironmentInvariants();
+    }
 
-    public static ITelemetry TelemetryClient;
     public static int Main(string[] args)
     {
         // Register a handler for SIGTERM to allow graceful shutdown of the application on Unix.
         // See https://github.com/dotnet/docs/issues/46226.
         using var termSignalRegistration = PosixSignalRegistration.Create(PosixSignal.SIGTERM, _ => Environment.Exit(0));
-
-        using AutomaticEncodingRestorer _ = new();
+        
+        using AutomaticEncodingRestorer _encodingRestorer = new();
 
         // Setting output encoding is not available on those platforms
         if (UILanguageOverride.OperatingSystemSupportsUtf8())
@@ -45,306 +109,331 @@ public static int Main(string[] args)
 
         DebugHelper.HandleDebugSwitch(ref args);
 
-        // Capture the current timestamp to calculate the host overhead.
-        DateTime mainTimeStamp = DateTime.Now;
-        TimeSpan startupTime = mainTimeStamp - Process.GetCurrentProcess().StartTime;
-
-        bool perfLogEnabled = Env.GetEnvironmentVariableAsBool("DOTNET_CLI_PERF_LOG", false);
-
-        if (string.IsNullOrEmpty(Env.GetEnvironmentVariable("MSBUILDFAILONDRIVEENUMERATINGWILDCARD")))
-        {
-            Environment.SetEnvironmentVariable("MSBUILDFAILONDRIVEENUMERATINGWILDCARD", "1");
-        }
+        InitializeProcess();
 
-        // Avoid create temp directory with root permission and later prevent access in non sudo
-        if (SudoEnvironmentDirectoryOverride.IsRunningUnderSudo())
-        {
-            perfLogEnabled = false;
-        }
-
-        PerformanceLogStartupInformation startupInfo = null;
-        if (perfLogEnabled)
+        try
         {
-            startupInfo = new PerformanceLogStartupInformation(mainTimeStamp);
-            PerformanceLogManager.InitializeAndStartCleanup(FileSystemWrapper.Default);
+            var exitCode = ProcessArgs(args);
+            s_mainActivity?.AddTag("process.exit.code", exitCode);
+            s_mainActivity?.SetStatus(ActivityStatusCode.Ok);
+            return exitCode;
         }
-
-        PerformanceLogEventListener perLogEventListener = null;
-        try
+        catch (Exception e) when (e.ShouldBeDisplayedAsError())
         {
-            if (perfLogEnabled)
-            {
-                perLogEventListener = PerformanceLogEventListener.Create(FileSystemWrapper.Default, PerformanceLogManager.Instance.CurrentLogDirectory);
-            }
-
-            PerformanceLogEventSource.Log.LogStartUpInformation(startupInfo);
-            PerformanceLogEventSource.Log.CLIStart();
-
-            InitializeProcess();
-
-            try
-            {
-                return ProcessArgs(args, startupTime);
-            }
-            catch (Exception e) when (e.ShouldBeDisplayedAsError())
-            {
-                Reporter.Error.WriteLine(CommandLoggingContext.IsVerbose
-                    ? e.ToString().Red().Bold()
-                    : e.Message.Red().Bold());
-
-                var commandParsingException = e as CommandParsingException;
-                if (commandParsingException != null && commandParsingException.ParseResult != null)
-                {
-                    commandParsingException.ParseResult.ShowHelp();
-                }
-
-                return 1;
-            }
-            catch (Exception e) when (!e.ShouldBeDisplayedAsError())
-            {
-                // If telemetry object has not been initialized yet. It cannot be collected
-                TelemetryEventEntry.SendFiltered(e);
-                Reporter.Error.WriteLine(e.ToString().Red().Bold());
+            Reporter.Error.WriteLine(CommandLoggingContext.IsVerbose
+                ? e.ToString().Red().Bold()
+                : e.Message.Red().Bold());
 
-                return 1;
-            }
-            finally
+            if (e is CommandParsingException commandParsingException && commandParsingException.ParseResult != null)
             {
-                PerformanceLogEventSource.Log.CLIStop();
+                commandParsingException.ParseResult.ShowHelp();
             }
+            s_mainActivity?.AddTag("process.exit.code", 1);
+            s_mainActivity?.SetStatus(ActivityStatusCode.Error);
+            return 1;
+        }
+        catch (Exception e) when (!e.ShouldBeDisplayedAsError())
+        {
+            // If telemetry object has not been initialized yet. It cannot be collected
+            TelemetryEventEntry.SendFiltered(e);
+            Reporter.Error.WriteLine(e.ToString().Red().Bold());
+            s_mainActivity?.AddTag("process.exit.code", 1);
+            s_mainActivity?.SetStatus(ActivityStatusCode.Error);
+            return 1;
         }
         finally
         {
-            if (perLogEventListener != null)
-            {
-                perLogEventListener.Dispose();
-            }
+            Shutdown(default!);
         }
     }
 
-    internal static int ProcessArgs(string[] args)
+    public static void Shutdown(PosixSignalContext context)
     {
-        return ProcessArgs(args, new TimeSpan(0));
+        s_sigIntRegistration.Dispose();
+        s_sigQuitRegistration.Dispose();
+        s_sigTermRegistration.Dispose();
+        s_mainActivity?.Stop();
+        s_tracerProvider?.ForceFlush();
+        s_metricsProvider?.ForceFlush();
+        Activities.Source.Dispose();
     }
 
-    internal static int ProcessArgs(string[] args, TimeSpan startupTime)
+    /// <summary>
+    /// Uses the OpenTelemetrySDK's Propagation API to derive the parent activity context and kind
+    /// from the DOTNET_CLI_TRACEPARENT and DOTNET_CLI_TRACESTATE environment variables.
+    /// </summary>
+    private static (System.Diagnostics.ActivityContext parentActivityContext, ActivityKind kind) DeriveParentActivityContextFromEnv()
     {
-        Dictionary<string, double> performanceData = [];
+        var traceParent = Env.GetEnvironmentVariable(Activities.TRACEPARENT);
+        var traceState = Env.GetEnvironmentVariable(Activities.TRACESTATE);
 
-        PerformanceLogEventSource.Log.BuiltInCommandParserStart();
-        ParseResult parseResult;
-        using (new PerformanceMeasurement(performanceData, "Parse Time"))
+        if (string.IsNullOrEmpty(traceParent))
         {
-            parseResult = Parser.Parse(args);
-
-            // Avoid create temp directory with root permission and later prevent access in non sudo
-            // This method need to be run very early before temp folder get created
-            // https://github.com/dotnet/sdk/issues/20195
-            SudoEnvironmentDirectoryOverride.OverrideEnvironmentVariableToTmp(parseResult);
+            return (default, ActivityKind.Internal);
         }
-        PerformanceLogEventSource.Log.BuiltInCommandParserStop();
 
-        using (IFirstTimeUseNoticeSentinel disposableFirstTimeUseNoticeSentinel = new FirstTimeUseNoticeSentinel())
+        var carrierMap = new Dictionary<string, IEnumerable<string>?> { { "traceparent", [traceParent] } };
+        if (!string.IsNullOrEmpty(traceState))
         {
-            IFirstTimeUseNoticeSentinel firstTimeUseNoticeSentinel = disposableFirstTimeUseNoticeSentinel;
-            IAspNetCertificateSentinel aspNetCertificateSentinel = new AspNetCertificateSentinel();
-            IFileSentinel toolPathSentinel = new FileSentinel(new FilePath(Path.Combine(CliFolderPathCalculator.DotnetUserProfileFolderPath, ToolPathSentinelFileName)));
+            carrierMap.Add("tracestate", [traceState]);
+        }
 
-            PerformanceLogEventSource.Log.TelemetryRegistrationStart();
+        // Use the OpenTelemetry Propagator to extract the parent activity context and kind. For some reason this isn't set by the OTel SDK like docs say it should be.
+        Sdk.SetDefaultTextMapPropagator(new CompositeTextMapPropagator([
+            new TraceContextPropagator(),
+            new BaggagePropagator()
+        ]));
+        var parentActivityContext = Propagators.DefaultTextMapPropagator.Extract(default, carrierMap, GetValueFromCarrier);
+        var kind = parentActivityContext.ActivityContext.IsRemote ? ActivityKind.Server : ActivityKind.Internal;
 
-            TelemetryClient ??= new Telemetry.Telemetry(firstTimeUseNoticeSentinel);
-            TelemetryEventEntry.Subscribe(TelemetryClient.TrackEvent);
-            TelemetryEventEntry.TelemetryFilter = new TelemetryFilter(Sha256Hasher.HashWithNormalizedCasing);
+        return (parentActivityContext.ActivityContext, kind);
 
-            PerformanceLogEventSource.Log.TelemetryRegistrationStop();
+        static IEnumerable<string>? GetValueFromCarrier(Dictionary<string, IEnumerable<string>?> carrier, string key)
+        {
+            return carrier.TryGetValue(key, out var value) ? value : null;
+        }
+    }
 
-            if (parseResult.GetValue(Parser.DiagOption) && parseResult.IsDotnetBuiltInCommand())
-            {
-                // We found --diagnostic or -d, but we still need to determine whether the option should
-                // be attached to the dotnet command or the subcommand.
-                if (args.DiagOptionPrecedesSubcommand(parseResult.RootSubCommandResult()))
-                {
-                    Environment.SetEnvironmentVariable(CommandLoggingContext.Variables.Verbose, bool.TrueString);
-                    CommandLoggingContext.SetVerbose(true);
-                    Reporter.Reset();
-                }
-            }
-            if (parseResult.HasOption(Parser.VersionOption) && parseResult.IsTopLevelDotnetCommand())
-            {
-                CommandLineInfo.PrintVersion();
-                return 0;
-            }
-            else if (parseResult.HasOption(Parser.InfoOption) && parseResult.IsTopLevelDotnetCommand())
+    private static void TrackHostStartup(ITelemetry telemetryClient, DateTime mainTimeStamp)
+    {
+        var hostStartupActivity = Activities.Source.StartActivity("host-startup");
+        hostStartupActivity?.SetStartTime(Process.GetCurrentProcess().StartTime);
+        if (telemetryClient.Enabled && hostStartupActivity is not null)
+        {
+            // Get the global.json state to report in telemetry along with this command invocation.
+            if (NativeWrapper.NETCoreSdkResolverNativeWrapper.GetGlobalJsonState(Environment.CurrentDirectory) is string globalJsonState)
             {
-                CommandLineInfo.PrintInfo();
-                return 0;
+                hostStartupActivity?.AddTag("dotnet.globalJson", globalJsonState);
             }
-            else
-            {
-                PerformanceLogEventSource.Log.FirstTimeConfigurationStart();
-
-                var environmentProvider = new EnvironmentProvider();
-
-                bool generateAspNetCertificate = environmentProvider.GetEnvironmentVariableAsBool(EnvironmentVariableNames.DOTNET_GENERATE_ASPNET_CERTIFICATE, defaultValue: true);
-                bool telemetryOptout = environmentProvider.GetEnvironmentVariableAsBool(EnvironmentVariableNames.TELEMETRY_OPTOUT, defaultValue: CompileOptions.TelemetryOptOutDefault);
-                bool addGlobalToolsToPath = environmentProvider.GetEnvironmentVariableAsBool(EnvironmentVariableNames.DOTNET_ADD_GLOBAL_TOOLS_TO_PATH, defaultValue: true);
-                bool nologo = environmentProvider.GetEnvironmentVariableAsBool(EnvironmentVariableNames.DOTNET_NOLOGO, defaultValue: false);
-                bool skipWorkloadIntegrityCheck = environmentProvider.GetEnvironmentVariableAsBool(EnvironmentVariableNames.DOTNET_SKIP_WORKLOAD_INTEGRITY_CHECK,
-                    // Default the workload integrity check skip to true if the command is being ran in CI. Otherwise, false.
-                    defaultValue: new CIEnvironmentDetectorForTelemetry().IsCIEnvironment());
-
-                ReportDotnetHomeUsage(environmentProvider);
+        }
+        hostStartupActivity?.SetEndTime(mainTimeStamp);
+    }
 
-                var isDotnetBeingInvokedFromNativeInstaller = false;
-                if (parseResult.CommandResult.Command.Name.Equals(Parser.InstallSuccessCommand.Name))
-                {
-                    aspNetCertificateSentinel = new NoOpAspNetCertificateSentinel();
-                    firstTimeUseNoticeSentinel = new NoOpFirstTimeUseNoticeSentinel();
-                    toolPathSentinel = new NoOpFileSentinel(exists: false);
-                    isDotnetBeingInvokedFromNativeInstaller = true;
-                }
+    /// <summary>
+    /// We have some behaviors in MSBuild that we want to enforce (either when using MSBuild API or by shelling out to it),
+    /// so we set those ASAP as globally as possible.
+    /// </summary>
+    private static void SetupMSBuildEnvironmentInvariants()
+    {
+        if (string.IsNullOrEmpty(Env.GetEnvironmentVariable("MSBUILDFAILONDRIVEENUMERATINGWILDCARD")))
+        {
+            Environment.SetEnvironmentVariable("MSBUILDFAILONDRIVEENUMERATINGWILDCARD", "1");
+        }
+    }
 
-                var dotnetFirstRunConfiguration = new DotnetFirstRunConfiguration(
-                    generateAspNetCertificate: generateAspNetCertificate,
-                    telemetryOptout: telemetryOptout,
-                    addGlobalToolsToPath: addGlobalToolsToPath,
-                    nologo: nologo,
-                    skipWorkloadIntegrityCheck: skipWorkloadIntegrityCheck);
-
-                string[] getStarOperators = ["getProperty", "getItem", "getTargetResult"];
-                char[] switchIndicators = ['-', '/'];
-                var getStarOptionPassed = parseResult.CommandResult.Tokens.Any(t =>
-                    getStarOperators.Any(o =>
-                    switchIndicators.Any(i => t.Value.StartsWith(i + o, StringComparison.OrdinalIgnoreCase))));
-
-                ConfigureDotNetForFirstTimeUse(
-                    firstTimeUseNoticeSentinel,
-                    aspNetCertificateSentinel,
-                    toolPathSentinel,
-                    isDotnetBeingInvokedFromNativeInstaller,
-                    dotnetFirstRunConfiguration,
-                    environmentProvider,
-                    performanceData,
-                    skipFirstTimeUseCheck: getStarOptionPassed);
-                PerformanceLogEventSource.Log.FirstTimeConfigurationStop();
-            }
+    private static string GetCommandName(ParseResult r)
+    {
+        if (r.Action is Parser.PrintVersionAction)
+        {
+            // If the action is PrintVersionAction, we return the command name as "dotnet --version"
+            return "dotnet --version";
+        }
+        else if (r.Action is Parser.PrintInfoAction)
+        {
+            // If the action is PrintHelpAction, we return the command name as "dotnet --help"
+            return "dotnet --info";
         }
 
-        if (CommandLoggingContext.IsVerbose)
+        // Walk the parent command tree to find the top-level command name and get the full command name for this parseresult.
+        List<string> parentNames = [r.CommandResult.Command.Name];
+        var current = r.CommandResult.Parent;
+        while (current is CommandResult parentCommandResult)
         {
-            Console.WriteLine($"Telemetry is: {(TelemetryClient.Enabled ? "Enabled" : "Disabled")}");
+            parentNames.Add(parentCommandResult.Command.Name);
+            current = parentCommandResult.Parent;
         }
-        PerformanceLogEventSource.Log.TelemetrySaveIfEnabledStart();
-        performanceData.Add("Startup Time", startupTime.TotalMilliseconds);
+        parentNames.Reverse();
+        return string.Join(' ', parentNames);
+    }
 
-        string globalJsonState = string.Empty;
-        if (TelemetryClient.Enabled)
+    private static void SetDisplayName(Activity? activity, ParseResult parseResult)
+    {
+        if (activity == null)
         {
-            // Get the global.json state to report in telemetry along with this command invocation.
-            globalJsonState = NativeWrapper.NETCoreSdkResolverNativeWrapper.GetGlobalJsonState(Environment.CurrentDirectory);
+            return;
         }
+        var name = GetCommandName(parseResult);
+
+        // Set the display name to the full command name
+        activity.DisplayName = name;
+
+        // Set the command name as an attribute for better filtering in telemetry
+        activity.SetTag("command.name", name);
+    }
 
-        TelemetryEventEntry.SendFiltered(Tuple.Create(parseResult, performanceData, globalJsonState));
-        PerformanceLogEventSource.Log.TelemetrySaveIfEnabledStop();
+    internal static int ProcessArgs(string[] args)
+    {
+        ParseResult parseResult = ParseArgs(args);
+        SetupDotnetFirstRun(parseResult);
 
-        int exitCode;
         if (parseResult.CanBeInvoked())
         {
-            InvokeBuiltInCommand(parseResult, out exitCode);
+            InvokeBuiltInCommand(parseResult, out var exitCode);
+            return exitCode;
         }
         else
         {
-            PerformanceLogEventSource.Log.ExtensibleCommandResolverStart();
             try
             {
-                string commandName = "dotnet-" + parseResult.GetValue(Parser.DotnetSubCommand);
-                var resolvedCommandSpec = CommandResolver.TryResolveCommandSpec(
-                    new DefaultCommandResolverPolicy(),
-                    commandName,
-                    args.GetSubArguments(),
-                    FrameworkConstants.CommonFrameworks.NetStandardApp15);
-
-                if (resolvedCommandSpec is null && TryRunFileBasedApp(parseResult) is { } fileBasedAppExitCode)
-                {
-                    exitCode = fileBasedAppExitCode;
-                }
-                else
-                {
-                    var resolvedCommand = CommandFactoryUsingResolver.CreateOrThrow(commandName, resolvedCommandSpec);
-                    PerformanceLogEventSource.Log.ExtensibleCommandResolverStop();
-
-                    PerformanceLogEventSource.Log.ExtensibleCommandStart();
-                    var result = resolvedCommand.Execute();
-                    PerformanceLogEventSource.Log.ExtensibleCommandStop();
-
-                    exitCode = result.ExitCode;
-                }
+                return LookupAndExecuteCommand(args, parseResult);
             }
             catch (CommandUnknownException e)
             {
                 Reporter.Error.WriteLine(e.Message.Red());
                 Reporter.Output.WriteLine(e.InstructionMessage);
-                exitCode = 1;
+                return 1;
             }
         }
+    }
 
-        TelemetryClient.TrackEvent("command/finish", properties: new Dictionary<string, string>
-                    {
-                        { "exitCode", exitCode.ToString() }
-                    },
-            measurements: new Dictionary<string, double>());
-
-        PerformanceLogEventSource.Log.TelemetryClientFlushStart();
-        TelemetryClient.Flush();
-        PerformanceLogEventSource.Log.TelemetryClientFlushStop();
+    private static int LookupAndExecuteCommand(string[] args, ParseResult parseResult)
+    {
+        var lookupExternalCommandActivity = Activities.Source.StartActivity("lookup-external-command");
+        string commandName = "dotnet-" + parseResult.GetValue(Parser.DotnetSubCommand);
+        var resolvedCommandSpec = CommandResolver.TryResolveCommandSpec(
+            new DefaultCommandResolverPolicy(),
+            commandName,
+            args.GetSubArguments(),
+            FrameworkConstants.CommonFrameworks.NetStandardApp15);
+        lookupExternalCommandActivity?.Dispose();
+
+        if (resolvedCommandSpec is null && TryRunFileBasedApp(parseResult) is { } fileBasedAppExitCode)
+        {
+            lookupExternalCommandActivity?.Dispose();
+            return fileBasedAppExitCode;
+        }
+        else
+        {
+            var resolvedCommand = CommandFactoryUsingResolver.CreateOrThrow(commandName, resolvedCommandSpec);
+            lookupExternalCommandActivity?.Dispose();
 
-        TelemetryClient.Dispose();
+            using var _executionActivity = Activities.Source.StartActivity("execute-extensible-command");
+            var result = resolvedCommand.Execute();
+            return result.ExitCode;
+        }
+    }
 
-        return exitCode;
+    private static void InvokeBuiltInCommand(ParseResult parseResult, out int exitCode)
+    {
+        Debug.Assert(parseResult.CanBeInvoked());
+        using var _invocationActivity = Activities.Source.StartActivity("invocation");
+        try
+        {
+            exitCode = parseResult.Invoke();
+            exitCode = AdjustExitCode(parseResult, exitCode);
+        }
+        catch (Exception exception)
+        {
+            exitCode = Parser.ExceptionHandler(exception, parseResult);
+        }
+    }
 
-        static int? TryRunFileBasedApp(ParseResult parseResult)
+    private static int? TryRunFileBasedApp(ParseResult parseResult)
+    {
+        // If we didn't match any built-in commands, and a C# file path is the first argument,
+        // parse as `dotnet run file.cs ..rest_of_args` instead.
+        if (parseResult.CommandResult.Command is RootCommand
+            && parseResult.GetValue(Parser.DotnetSubCommand) is { } unmatchedCommandOrFile
+            && VirtualProjectBuildingCommand.IsValidEntryPointPath(unmatchedCommandOrFile))
         {
-            // If we didn't match any built-in commands, and a C# file path is the first argument,
-            // parse as `dotnet run --file file.cs ..rest_of_args` instead.
-            if (parseResult.GetValue(Parser.DotnetSubCommand) is { } unmatchedCommandOrFile
-                && VirtualProjectBuildingCommand.IsValidEntryPointPath(unmatchedCommandOrFile))
+            List<string> otherTokens = new(parseResult.Tokens.Count - 1);
+            foreach (var token in parseResult.Tokens)
             {
-                List<string> otherTokens = new(parseResult.Tokens.Count - 1);
-                foreach (var token in parseResult.Tokens)
+                if (token.Type != TokenType.Argument || token.Value != unmatchedCommandOrFile)
                 {
-                    if (token.Type != TokenType.Argument || token.Value != unmatchedCommandOrFile)
-                    {
-                        otherTokens.Add(token.Value);
-                    }
+                    otherTokens.Add(token.Value);
                 }
+            }
+            parseResult = Parser.Parse(["run", unmatchedCommandOrFile, .. otherTokens]);
 
-                parseResult = Parser.Parse(["run", "--file", unmatchedCommandOrFile, .. otherTokens]);
+            InvokeBuiltInCommand(parseResult, out var exitCode);
+            return exitCode;
+        }
 
-                InvokeBuiltInCommand(parseResult, out var exitCode);
-                return exitCode;
-            }
+        return null;
+    }
+
+    private static ITelemetry InitializeTelemetry()
+    {
+        var telemetryClient = new Telemetry.Telemetry();
+        TelemetryEventEntry.Subscribe(telemetryClient.TrackEvent);
+        TelemetryEventEntry.TelemetryFilter = new TelemetryFilter(Sha256Hasher.HashWithNormalizedCasing);
 
-            return null;
+        if (CommandLoggingContext.IsVerbose)
+        {
+            Console.WriteLine($"Telemetry is: {(telemetryClient.Enabled ? "Enabled" : "Disabled")}");
         }
 
-        static void InvokeBuiltInCommand(ParseResult parseResult, out int exitCode)
+        return telemetryClient;
+    }
+
+    private static ParseResult ParseArgs(string[] args)
+    {
+        ParseResult parseResult;
+        using (var _parseActivity = Activities.Source.StartActivity("parse"))
         {
-            Debug.Assert(parseResult.CanBeInvoked());
+            parseResult = Parser.Parse(args);
+
+            // Avoid create temp directory with root permission and later prevent access in non sudo
+            // This method need to be run very early before temp folder get created
+            // https://github.com/dotnet/sdk/issues/20195
+            SudoEnvironmentDirectoryOverride.OverrideEnvironmentVariableToTmp(parseResult);
+        }
 
-            PerformanceLogEventSource.Log.BuiltInCommandStart();
+        SetDisplayName(s_mainActivity, parseResult);
 
-            try
-            {
-                exitCode = Parser.Invoke(parseResult);
-                exitCode = AdjustExitCode(parseResult, exitCode);
-            }
-            catch (Exception exception)
-            {
-                exitCode = Parser.ExceptionHandler(exception, parseResult);
-            }
+        return parseResult;
+    }
 
-            PerformanceLogEventSource.Log.BuiltInCommandStop();
+    private static void SetupDotnetFirstRun(ParseResult parseResult)
+    {
+        using var _ = Activities.Source.StartActivity("first-time-use");
+        IFirstTimeUseNoticeSentinel firstTimeUseNoticeSentinel = new FirstTimeUseNoticeSentinel();
+        IAspNetCertificateSentinel aspNetCertificateSentinel = new AspNetCertificateSentinel();
+        string toolPath = Path.Combine(CliFolderPathCalculator.DotnetUserProfileFolderPath, s_toolPathSentinelFileName);
+        IFileSentinel toolPathSentinel = new FileSentinel(new FilePath(toolPath));
+
+        var environmentProvider = new EnvironmentProvider();
+        bool generateAspNetCertificate = environmentProvider.GetEnvironmentVariableAsBool(EnvironmentVariableNames.DOTNET_GENERATE_ASPNET_CERTIFICATE, defaultValue: true);
+        bool telemetryOptout = environmentProvider.GetEnvironmentVariableAsBool(EnvironmentVariableNames.TELEMETRY_OPTOUT, defaultValue: CompileOptions.TelemetryOptOutDefault);
+        bool addGlobalToolsToPath = environmentProvider.GetEnvironmentVariableAsBool(EnvironmentVariableNames.DOTNET_ADD_GLOBAL_TOOLS_TO_PATH, defaultValue: true);
+        bool nologo = environmentProvider.GetEnvironmentVariableAsBool(EnvironmentVariableNames.DOTNET_NOLOGO, defaultValue: false);
+        bool skipWorkloadIntegrityCheck = environmentProvider.GetEnvironmentVariableAsBool(EnvironmentVariableNames.DOTNET_SKIP_WORKLOAD_INTEGRITY_CHECK,
+            // Default the workload integrity check skip to true if the command is being ran in CI. Otherwise, false.
+            defaultValue: new CIEnvironmentDetectorForTelemetry().IsCIEnvironment());
+
+        ReportDotnetHomeUsage(environmentProvider);
+
+        var isDotnetBeingInvokedFromNativeInstaller = false;
+        if (parseResult.CommandResult.Command.Name.Equals(Parser.InstallSuccessCommand.Name))
+        {
+            aspNetCertificateSentinel = new NoOpAspNetCertificateSentinel();
+            firstTimeUseNoticeSentinel = new NoOpFirstTimeUseNoticeSentinel();
+            toolPathSentinel = new NoOpFileSentinel(exists: false);
+            isDotnetBeingInvokedFromNativeInstaller = true;
         }
+
+        var dotnetFirstRunConfiguration = new DotnetFirstRunConfiguration(
+            generateAspNetCertificate: generateAspNetCertificate,
+            telemetryOptout: telemetryOptout,
+            addGlobalToolsToPath: addGlobalToolsToPath,
+            nologo: nologo,
+            skipWorkloadIntegrityCheck: skipWorkloadIntegrityCheck);
+
+        string[] getStarOperators = ["getProperty", "getItem", "getTargetResult"];
+        char[] switchIndicators = ['-', '/'];
+        var getStarOptionPassed = parseResult.CommandResult.Tokens.Any(t =>
+            getStarOperators.Any(o =>
+            switchIndicators.Any(i => t.Value.StartsWith(i + o, StringComparison.OrdinalIgnoreCase))));
+
+        ConfigureDotNetForFirstTimeUse(
+            firstTimeUseNoticeSentinel,
+            aspNetCertificateSentinel,
+            toolPathSentinel,
+            isDotnetBeingInvokedFromNativeInstaller,
+            dotnetFirstRunConfiguration,
+            environmentProvider,
+            skipFirstTimeUseCheck: getStarOptionPassed);
     }
 
     private static int AdjustExitCode(ParseResult parseResult, int exitCode)
@@ -377,11 +466,7 @@ private static void ReportDotnetHomeUsage(IEnvironmentProvider provider)
             return;
         }
 
-        Reporter.Verbose.WriteLine(
-            string.Format(
-                LocalizableStrings.DotnetCliHomeUsed,
-                home,
-                CliFolderPathCalculator.DotnetHomeVariableName));
+        Reporter.Verbose.WriteLine(string.Format(LocalizableStrings.DotnetCliHomeUsed, home, CliFolderPathCalculator.DotnetHomeVariableName));
     }
 
     private static void ConfigureDotNetForFirstTimeUse(
@@ -391,7 +476,6 @@ private static void ConfigureDotNetForFirstTimeUse(
        bool isDotnetBeingInvokedFromNativeInstaller,
        DotnetFirstRunConfiguration dotnetFirstRunConfiguration,
        IEnvironmentProvider environmentProvider,
-       Dictionary<string, double> performanceMeasurements,
        bool skipFirstTimeUseCheck)
     {
         var isFirstTimeUse = !firstTimeUseNoticeSentinel.Exists() && !skipFirstTimeUseCheck;
@@ -407,7 +491,6 @@ private static void ConfigureDotNetForFirstTimeUse(
             dotnetFirstRunConfiguration,
             reporter,
             environmentPath,
-            performanceMeasurements,
             skipFirstTimeUseCheck: skipFirstTimeUseCheck);
 
         dotnetConfigurer.Configure();
diff --git a/src/Cli/dotnet/Telemetry/ITelemetry.cs b/src/Cli/dotnet/Telemetry/ITelemetry.cs
index b8ee7c98e118..b85b3f7ccdd7 100644
--- a/src/Cli/dotnet/Telemetry/ITelemetry.cs
+++ b/src/Cli/dotnet/Telemetry/ITelemetry.cs
@@ -1,17 +1,11 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 namespace Microsoft.DotNet.Cli.Telemetry;
 
 public interface ITelemetry
 {
     bool Enabled { get; }
 
-    void TrackEvent(string eventName, IDictionary<string, string> properties, IDictionary<string, double> measurements);
-
-    void Flush();
-
-    void Dispose();
+    void TrackEvent(string eventName, IDictionary<string, string?>? properties, IDictionary<string, double>? measurements);
 }
diff --git a/src/Cli/dotnet/Telemetry/PersistenceChannel/BaseStorageService.cs b/src/Cli/dotnet/Telemetry/PersistenceChannel/BaseStorageService.cs
deleted file mode 100644
index 2966dfc205a8..000000000000
--- a/src/Cli/dotnet/Telemetry/PersistenceChannel/BaseStorageService.cs
+++ /dev/null
@@ -1,61 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable disable
-
-using Microsoft.ApplicationInsights.Channel;
-
-namespace Microsoft.DotNet.Cli.Telemetry.PersistenceChannel;
-
-internal abstract class BaseStorageService
-{
-    /// <summary>
-    ///     Peeked transmissions dictionary (maps file name to its full path). Holds all the transmissions that were peeked.
-    /// </summary>
-    /// <remarks>
-    ///     Note: The value (=file's full path) is not required in the Storage implementation.
-    ///     If there was a concurrent Abstract Data Type Set it would have been used instead.
-    ///     However, since there is no concurrent Set, dictionary is used and the second value is ignored.
-    /// </remarks>
-    protected IDictionary<string, string> PeekedTransmissions;
-
-    /// <summary>
-    ///     Gets or sets the maximum size of the storage in bytes. When limit is reached, the Enqueue method will drop new
-    ///     transmissions.
-    /// </summary>
-    internal ulong CapacityInBytes { get; set; }
-
-    /// <summary>
-    ///     Gets or sets the maximum number of files. When limit is reached, the Enqueue method will drop new transmissions.
-    /// </summary>
-    internal uint MaxFiles { get; set; }
-
-    internal abstract string StorageDirectoryPath { get; }
-
-    /// <summary>
-    ///     Initializes the <see cref="BaseStorageService" />
-    /// </summary>
-    /// <param name="desireStorageDirectoryPath">A folder name. Under this folder all the transmissions will be saved.</param>
-    internal abstract void Init(string desireStorageDirectoryPath);
-
-    internal abstract StorageTransmission Peek();
-
-    internal abstract void Delete(StorageTransmission transmission);
-
-    internal abstract Task EnqueueAsync(Transmission transmission);
-
-    protected void OnPeekedItemDisposed(string fileName)
-    {
-        try
-        {
-            if (PeekedTransmissions.ContainsKey(fileName))
-            {
-                PeekedTransmissions.Remove(fileName);
-            }
-        }
-        catch (Exception e)
-        {
-            PersistenceChannelDebugLog.WriteException(e, "Failed to remove the item from storage items.");
-        }
-    }
-}
diff --git a/src/Cli/dotnet/Telemetry/PersistenceChannel/FixedSizeQueue.cs b/src/Cli/dotnet/Telemetry/PersistenceChannel/FixedSizeQueue.cs
deleted file mode 100644
index 4a80be224e9c..000000000000
--- a/src/Cli/dotnet/Telemetry/PersistenceChannel/FixedSizeQueue.cs
+++ /dev/null
@@ -1,43 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable disable
-
-namespace Microsoft.DotNet.Cli.Telemetry.PersistenceChannel;
-
-/// <summary>
-///     A light fixed size queue. If Enqueue is called and queue's limit has reached the last item will be removed.
-///     This data structure is thread safe.
-/// </summary>
-internal class FixedSizeQueue<T>
-{
-    private readonly int _maxSize;
-    private readonly Queue<T> _queue = new();
-    private readonly object _queueLockObj = new();
-
-    internal FixedSizeQueue(int maxSize)
-    {
-        _maxSize = maxSize;
-    }
-
-    internal void Enqueue(T item)
-    {
-        lock (_queueLockObj)
-        {
-            if (_queue.Count == _maxSize)
-            {
-                _queue.Dequeue();
-            }
-
-            _queue.Enqueue(item);
-        }
-    }
-
-    internal bool Contains(T item)
-    {
-        lock (_queueLockObj)
-        {
-            return _queue.Contains(item);
-        }
-    }
-}
diff --git a/src/Cli/dotnet/Telemetry/PersistenceChannel/FlushManager.cs b/src/Cli/dotnet/Telemetry/PersistenceChannel/FlushManager.cs
deleted file mode 100644
index 8d14b740cca0..000000000000
--- a/src/Cli/dotnet/Telemetry/PersistenceChannel/FlushManager.cs
+++ /dev/null
@@ -1,57 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable disable
-
-using Microsoft.ApplicationInsights.Channel;
-using Microsoft.ApplicationInsights.Extensibility.Implementation;
-using IChannelTelemetry = Microsoft.ApplicationInsights.Channel.ITelemetry;
-
-namespace Microsoft.DotNet.Cli.Telemetry.PersistenceChannel;
-
-/// <summary>
-///     This class handles all the logic for flushing the In Memory buffer to the persistent storage.
-/// </summary>
-internal class FlushManager
-{
-    /// <summary>
-    ///     The storage that is used to persist all the transmissions.
-    /// </summary>
-    private readonly BaseStorageService _storage;
-
-    /// <summary>
-    ///     Initializes a new instance of the <see cref="FlushManager" /> class.
-    /// </summary>
-    /// <param name="storage">The storage that persists the telemetries.</param>
-    internal FlushManager(BaseStorageService storage)
-    {
-        _storage = storage;
-    }
-
-    /// <summary>
-    ///     Gets or sets the service endpoint.
-    /// </summary>
-    /// <remarks>
-    ///     Q: Why flushManager knows about the endpoint?
-    ///     A: Storage stores Transmission objects and Transmission objects contain the endpoint address.
-    /// </remarks>
-    internal Uri EndpointAddress { get; set; }
-
-    /// <summary>
-    ///     Persist the in-memory telemetry items.
-    /// </summary>
-    internal void Flush(IChannelTelemetry telemetryItem)
-    {
-        if (telemetryItem != null)
-        {
-            byte[] data = JsonSerializer.Serialize([telemetryItem]);
-            Transmission transmission = new(
-                EndpointAddress,
-                data,
-                "application/x-json-stream",
-                JsonSerializer.CompressionType);
-
-            _storage.EnqueueAsync(transmission).ConfigureAwait(false).GetAwaiter().GetResult();
-        }
-    }
-}
diff --git a/src/Cli/dotnet/Telemetry/PersistenceChannel/PersistenceChannel.cs b/src/Cli/dotnet/Telemetry/PersistenceChannel/PersistenceChannel.cs
deleted file mode 100644
index 69affdc523a8..000000000000
--- a/src/Cli/dotnet/Telemetry/PersistenceChannel/PersistenceChannel.cs
+++ /dev/null
@@ -1,114 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable disable
-
-using Microsoft.ApplicationInsights.Channel;
-using IChannelTelemetry = Microsoft.ApplicationInsights.Channel.ITelemetry;
-
-namespace Microsoft.DotNet.Cli.Telemetry.PersistenceChannel;
-
-/// <summary>
-///     Represents a communication channel for sending telemetry to Application Insights via HTTPS.
-/// </summary>
-internal sealed class PersistenceChannel : ITelemetryChannel
-{
-    internal const string TelemetryServiceEndpoint = "https://dc.services.visualstudio.com/v2/track";
-
-    private readonly FlushManager _flushManager;
-
-    private int _disposeCount;
-    private readonly BaseStorageService _storage;
-    private readonly PersistenceTransmitter _transmitter;
-
-    /// <summary>
-    ///     Initializes a new instance of the <see cref="PersistenceChannel" /> class.
-    /// </summary>
-    /// <param name="storageDirectoryPath">
-    ///     Full path of a directory name. Under this folder all the transmissions will be saved.
-    ///     Setting this value groups channels, even from different processes.
-    ///     If 2 (or more) channels has the same <c>storageFolderName</c> only one channel will perform the sending even if the
-    ///     channel is in a different process/AppDomain/Thread.
-    /// </param>
-    /// <param name="sendersCount">
-    ///     Defines the number of senders. A sender is a long-running thread that sends telemetry batches in intervals defined
-    ///     by <see cref="SendingInterval" />.
-    ///     So the amount of senders also defined the maximum amount of http channels opened at the same time.
-    /// </param>
-    public PersistenceChannel(string storageDirectoryPath = null, int sendersCount = 1)
-    {
-        _storage = new StorageService();
-        _storage.Init(storageDirectoryPath);
-        _transmitter = new PersistenceTransmitter(_storage, sendersCount);
-        _flushManager = new FlushManager(_storage);
-        EndpointAddress = TelemetryServiceEndpoint;
-    }
-
-    /// <summary>
-    ///     Gets or sets an interval between each successful sending.
-    /// </summary>
-    /// <remarks>
-    ///     On error scenario this value is ignored and the interval will be defined using an exponential back-off
-    ///     algorithm.
-    /// </remarks>
-    public TimeSpan? SendingInterval
-    {
-        get => _transmitter.SendingInterval;
-        set => _transmitter.SendingInterval = value;
-    }
-
-
-    /// <summary>
-    ///     Gets or sets the maximum amount of files allowed in storage. When the limit is reached telemetries will be dropped.
-    /// </summary>
-    public uint MaxTransmissionStorageFilesCapacity
-    {
-        get => _storage.MaxFiles;
-        set => _storage.MaxFiles = value;
-    }
-
-    /// <summary>
-    ///     This flag has no effect. But it is required by base class
-    /// </summary>
-    public bool? DeveloperMode { get; set; }
-
-    /// <summary>
-    ///     Gets or sets the HTTP address where the telemetry is sent.
-    /// </summary>
-    public string EndpointAddress
-    {
-        get => _flushManager.EndpointAddress.ToString();
-
-        set
-        {
-            string address = value ?? TelemetryServiceEndpoint;
-            _flushManager.EndpointAddress = new Uri(address);
-        }
-    }
-
-    /// <summary>
-    ///     Releases unmanaged and - optionally - managed resources.
-    /// </summary>
-    public void Dispose()
-    {
-        if (Interlocked.Increment(ref _disposeCount) == 1)
-        {
-            _transmitter?.Dispose();
-        }
-    }
-
-    /// <summary>
-    ///     Sends an instance of ITelemetry through the channel.
-    /// </summary>
-    public void Send(IChannelTelemetry item)
-    {
-        _flushManager.Flush(item);
-    }
-
-    /// <summary>
-    ///     No operation, send will always flush. So nothing will be in memory
-    /// </summary>
-    public void Flush()
-    {
-    }
-}
diff --git a/src/Cli/dotnet/Telemetry/PersistenceChannel/PersistenceChannelDebugLog.cs b/src/Cli/dotnet/Telemetry/PersistenceChannel/PersistenceChannelDebugLog.cs
deleted file mode 100644
index ff695b79e6c3..000000000000
--- a/src/Cli/dotnet/Telemetry/PersistenceChannel/PersistenceChannelDebugLog.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable disable
-
-using System.Globalization;
-using Microsoft.DotNet.Cli.Utils;
-
-namespace Microsoft.DotNet.Cli.Telemetry.PersistenceChannel;
-
-internal static class PersistenceChannelDebugLog
-{
-    private static readonly bool _isEnabled = IsEnabledByEnvironment();
-
-    private static bool IsEnabledByEnvironment()
-    {
-        var environmentProvider = new EnvironmentProvider();
-        return environmentProvider.GetEnvironmentVariableAsBool("DOTNET_ENABLE_PERSISTENCE_CHANNEL_DEBUG_OUTPUT", false);
-    }
-
-    public static void WriteLine(string message)
-    {
-        if (_isEnabled)
-        {
-            Reporter.Output.WriteLine(message);
-        }
-    }
-
-    internal static void WriteException(Exception exception, string format, params string[] args)
-    {
-        var message = string.Format(CultureInfo.InvariantCulture, format, args);
-        WriteLine(string.Format(CultureInfo.InvariantCulture, "{0} Exception: {1}", message, exception.ToString()));
-    }
-}
diff --git a/src/Cli/dotnet/Telemetry/PersistenceChannel/PersistenceTransmitter.cs b/src/Cli/dotnet/Telemetry/PersistenceChannel/PersistenceTransmitter.cs
deleted file mode 100644
index 0cede405eb04..000000000000
--- a/src/Cli/dotnet/Telemetry/PersistenceChannel/PersistenceTransmitter.cs
+++ /dev/null
@@ -1,84 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable disable
-
-namespace Microsoft.DotNet.Cli.Telemetry.PersistenceChannel;
-
-/// <summary>
-///     Implements throttled and persisted transmission of telemetry to Application Insights.
-/// </summary>
-internal class PersistenceTransmitter : IDisposable
-{
-    /// <summary>
-    ///     The number of times this object was disposed.
-    /// </summary>
-    private int _disposeCount;
-
-    /// <summary>
-    ///     A list of senders that sends transmissions.
-    /// </summary>
-    private readonly List<Sender> _senders = [];
-
-    /// <summary>
-    ///     The storage that is used to persist all the transmissions.
-    /// </summary>
-    private readonly BaseStorageService _storage;
-
-    /// <summary>
-    ///     Initializes a new instance of the <see cref="PersistenceTransmitter" /> class.
-    /// </summary>
-    /// <param name="storage">The transmissions storage.</param>
-    /// <param name="sendersCount">The number of senders to create.</param>
-    /// <param name="createSenders">
-    ///     A boolean value that indicates if this class should try and create senders. This is a
-    ///     workaround for unit tests purposes only.
-    /// </param>
-    internal PersistenceTransmitter(BaseStorageService storage, int sendersCount, bool createSenders = true)
-    {
-        _storage = storage;
-        if (createSenders)
-        {
-            for (int i = 0; i < sendersCount; i++)
-            {
-                _senders.Add(new Sender(_storage, this));
-            }
-        }
-    }
-
-    /// <summary>
-    ///     Gets or sets the interval between each successful sending.
-    /// </summary>
-    internal TimeSpan? SendingInterval { get; set; }
-
-    /// <summary>
-    ///     Disposes the object.
-    /// </summary>
-    public void Dispose()
-    {
-        if (Interlocked.Increment(ref _disposeCount) == 1)
-        {
-            StopSenders();
-        }
-    }
-
-    /// <summary>
-    ///     Stops the senders.
-    /// </summary>
-    /// <remarks>As long as there is no Start implementation, this method should only be called from Dispose.</remarks>
-    private void StopSenders()
-    {
-        if (_senders == null)
-        {
-            return;
-        }
-
-        List<Task> stoppedTasks = [];
-        foreach (Sender sender in _senders)
-        {
-            stoppedTasks.Add(sender.StopAsync());
-        }
-
-        Task.WaitAll([.. stoppedTasks]);
-    }
-}
diff --git a/src/Cli/dotnet/Telemetry/PersistenceChannel/Sender.cs b/src/Cli/dotnet/Telemetry/PersistenceChannel/Sender.cs
deleted file mode 100644
index 6e0f7ceceaa9..000000000000
--- a/src/Cli/dotnet/Telemetry/PersistenceChannel/Sender.cs
+++ /dev/null
@@ -1,336 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable disable
-
-using System.Net;
-using System.Net.NetworkInformation;
-
-namespace Microsoft.DotNet.Cli.Telemetry.PersistenceChannel;
-
-/// <summary>
-///     Fetch transmissions from the storage and sends it.
-/// </summary>
-internal class Sender : IDisposable
-{
-    /// <summary>
-    ///     The default sending interval.
-    /// </summary>
-    private readonly TimeSpan _defaultSendingInterval;
-
-    /// <summary>
-    ///     A wait handle that flags the sender when to start sending again. The type is protected for unit test.
-    /// </summary>
-    protected readonly AutoResetEvent DelayHandler;
-
-    /// <summary>
-    ///     Holds the maximum time for the exponential back-off algorithm. The sending interval will grow on every HTTP
-    ///     Exception until this max value.
-    /// </summary>
-    private readonly TimeSpan _maxIntervalBetweenRetries = TimeSpan.FromHours(1);
-
-    /// <summary>
-    ///     When storage is empty it will be queried again after this interval.
-    ///     Decreasing to 5 sec to send first data (users and sessions).
-    /// </summary>
-    private readonly TimeSpan _sendingIntervalOnNoData = TimeSpan.FromSeconds(5);
-
-    /// <summary>
-    ///     A wait handle that is being set when Sender is no longer sending.
-    /// </summary>
-    private readonly AutoResetEvent _stoppedHandler;
-
-    /// <summary>
-    ///     The number of times this object was disposed.
-    /// </summary>
-    private int _disposeCount;
-
-    /// <summary>
-    ///     The amount of time to wait, in the stop method, until the last transmission is sent.
-    ///     If time expires, the stop method will return even if the transmission hasn't been sent.
-    /// </summary>
-    private readonly TimeSpan _drainingTimeout;
-
-    /// <summary>
-    ///     A boolean value that indicates if the sender should be stopped. The sender's while loop is checking this boolean
-    ///     value.
-    /// </summary>
-    private bool _stopped;
-
-    /// <summary>
-    ///     The transmissions storage.
-    /// </summary>
-    private readonly BaseStorageService _storage;
-
-    /// <summary>
-    ///     Holds the transmitter.
-    /// </summary>
-    private readonly PersistenceTransmitter _transmitter;
-
-    /// <summary>
-    ///     Initializes a new instance of the <see cref="Sender" /> class.
-    /// </summary>
-    /// <param name="storage">The storage that holds the transmissions to send.</param>
-    /// <param name="transmitter">
-    ///     The persistence transmitter that manages this Sender.
-    ///     The transmitter will be used as a configuration class, it exposes properties like SendingInterval that will be read
-    ///     by Sender.
-    /// </param>
-    /// <param name="startSending">
-    ///     A boolean value that determines if Sender should start sending immediately. This is only
-    ///     used for unit tests.
-    /// </param>
-    internal Sender(BaseStorageService storage, PersistenceTransmitter transmitter, bool startSending = true)
-    {
-        _stopped = false;
-        DelayHandler = new AutoResetEvent(false);
-        _stoppedHandler = new AutoResetEvent(false);
-        _drainingTimeout = TimeSpan.FromSeconds(100);
-        _defaultSendingInterval = TimeSpan.FromSeconds(5);
-
-        _transmitter = transmitter;
-        _storage = storage;
-
-        if (startSending)
-        {
-            // It is currently possible for the long - running task to be executed(and thereby block during WaitOne) on the UI thread when
-            // called by a task scheduled on the UI thread. Explicitly specifying TaskScheduler.Default 
-            // when calling StartNew guarantees that Sender never blocks the main thread.
-            Task.Factory.StartNew(SendLoop, CancellationToken.None, TaskCreationOptions.LongRunning,
-                    TaskScheduler.Default)
-                .ContinueWith(
-                    t => PersistenceChannelDebugLog.WriteException(t.Exception, "Sender: Failure in SendLoop"),
-                    TaskContinuationOptions.OnlyOnFaulted);
-        }
-    }
-
-    /// <summary>
-    ///     Gets the interval between each successful sending.
-    /// </summary>
-    private TimeSpan SendingInterval
-    {
-        get
-        {
-            if (_transmitter.SendingInterval != null)
-            {
-                return _transmitter.SendingInterval.Value;
-            }
-
-            return _defaultSendingInterval;
-        }
-    }
-
-    /// <summary>
-    ///     Disposes the managed objects.
-    /// </summary>
-    public void Dispose()
-    {
-        if (Interlocked.Increment(ref _disposeCount) == 1)
-        {
-            StopAsync().ConfigureAwait(false).GetAwaiter().GetResult();
-
-            DelayHandler.Dispose();
-            _stoppedHandler.Dispose();
-        }
-    }
-
-    /// <summary>
-    ///     Stops the sender.
-    /// </summary>
-    internal Task StopAsync()
-    {
-        // After delayHandler is set, a sending iteration will immediately start. 
-        // Setting <c>stopped</c> to true, will cause the iteration to skip the actual sending and stop immediately. 
-        _stopped = true;
-        DelayHandler.Set();
-
-        // if delayHandler was set while a transmission was being sent, the return task will wait for it to finish, for an additional second,
-        // before it will mark the task as completed. 
-        return Task.Run(() =>
-        {
-            try
-            {
-                _stoppedHandler.WaitOne(_drainingTimeout);
-            }
-            catch (ObjectDisposedException)
-            {
-            }
-        });
-    }
-
-    /// <summary>
-    ///     Send transmissions in a loop.
-    /// </summary>
-    protected void SendLoop()
-    {
-        TimeSpan prevSendingInterval = TimeSpan.Zero;
-        TimeSpan sendingInterval = _sendingIntervalOnNoData;
-        try
-        {
-            while (!_stopped)
-            {
-                using (StorageTransmission transmission = _storage.Peek())
-                {
-                    if (_stopped)
-                    {
-                        // This second verification is required for cases where 'stopped' was set while peek was happening. 
-                        // Once the actual sending starts the design is to wait until it finishes and deletes the transmission. 
-                        // So no extra validation is required.
-                        break;
-                    }
-
-                    // If there is a transmission to send - send it. 
-                    if (transmission != null)
-                    {
-                        bool shouldRetry = Send(transmission, ref sendingInterval);
-                        if (!shouldRetry)
-                        {
-                            // If retry is not required - delete the transmission.
-                            _storage.Delete(transmission);
-                        }
-                    }
-                    else
-                    {
-                        sendingInterval = _sendingIntervalOnNoData;
-                    }
-                }
-
-                LogInterval(prevSendingInterval, sendingInterval);
-                DelayHandler.WaitOne(sendingInterval);
-                prevSendingInterval = sendingInterval;
-            }
-
-            _stoppedHandler.Set();
-        }
-        catch (ObjectDisposedException)
-        {
-        }
-    }
-
-    /// <summary>
-    ///     Sends a transmission and handle errors.
-    /// </summary>
-    /// <param name="transmission">The transmission to send.</param>
-    /// <param name="nextSendInterval">
-    ///     When this value returns it will hold a recommendation for when to start the next sending
-    ///     iteration.
-    /// </param>
-    /// <returns>True, if there was sent error and we need to retry sending, otherwise false.</returns>
-    protected virtual bool Send(StorageTransmission transmission, ref TimeSpan nextSendInterval)
-    {
-        try
-        {
-            if (transmission != null)
-            {
-                bool isConnected = NetworkInterface.GetIsNetworkAvailable();
-
-                // there is no internet connection available, return than.
-                if (!isConnected)
-                {
-                    PersistenceChannelDebugLog.WriteLine(
-                        "Cannot send data to the server. Internet connection is not available");
-                    return true;
-                }
-
-                transmission.SendAsync().ConfigureAwait(false).GetAwaiter().GetResult();
-
-                // After a successful sending, try immediately to send another transmission. 
-                nextSendInterval = SendingInterval;
-            }
-        }
-        catch (WebException e)
-        {
-            int? statusCode = GetStatusCode(e);
-            nextSendInterval = CalculateNextInterval(statusCode, nextSendInterval, _maxIntervalBetweenRetries);
-            return IsRetryable(statusCode, e.Status);
-        }
-        catch (Exception e)
-        {
-            nextSendInterval = CalculateNextInterval(null, nextSendInterval, _maxIntervalBetweenRetries);
-            PersistenceChannelDebugLog.WriteException(e, "Unknown exception during sending");
-        }
-
-        return false;
-    }
-
-    /// <summary>
-    ///     Log next interval. Only log the interval when it changes by more then a minute. So if interval grow by 1 minute or
-    ///     decreased by 1 minute it will be logged.
-    ///     Logging every interval will just make the log noisy.
-    /// </summary>
-    private static void LogInterval(TimeSpan prevSendInterval, TimeSpan nextSendInterval)
-    {
-        if (Math.Abs(nextSendInterval.TotalSeconds - prevSendInterval.TotalSeconds) > 60)
-        {
-            PersistenceChannelDebugLog.WriteLine("next sending interval: " + nextSendInterval);
-        }
-    }
-
-    /// <summary>
-    ///     Return the status code from the web exception or null if no such code exists.
-    /// </summary>
-    private static int? GetStatusCode(WebException e)
-    {
-        if (e.Response is HttpWebResponse httpWebResponse)
-        {
-            return (int)httpWebResponse.StatusCode;
-        }
-
-        return null;
-    }
-
-    /// <summary>
-    ///     Returns true if <paramref name="httpStatusCode" /> or <paramref name="webExceptionStatus" /> are retryable.
-    /// </summary>
-    private static bool IsRetryable(int? httpStatusCode, WebExceptionStatus webExceptionStatus)
-    {
-        switch (webExceptionStatus)
-        {
-            case WebExceptionStatus.ProxyNameResolutionFailure:
-            case WebExceptionStatus.NameResolutionFailure:
-            case WebExceptionStatus.Timeout:
-            case WebExceptionStatus.ConnectFailure:
-                return true;
-        }
-
-        if (httpStatusCode == null)
-        {
-            return false;
-        }
-
-        switch (httpStatusCode.Value)
-        {
-            case 503: // Server in maintenance. 
-            case 408: // invalid request
-            case 500: // Internal Server Error                                                
-            case 502: // Bad Gateway, can be common when there is no network. 
-            case 511: // Network Authentication Required
-                return true;
-        }
-
-        return false;
-    }
-
-    /// <summary>
-    ///     Calculates the next interval using exponential back-off algorithm (with the exceptions of few error codes that
-    ///     reset the interval to <see cref="SendingInterval" />.
-    /// </summary>
-    private TimeSpan CalculateNextInterval(int? httpStatusCode, TimeSpan currentSendInterval, TimeSpan maxInterval)
-    {
-        // if item is expired, no need for exponential back-off
-        if (httpStatusCode != null && httpStatusCode.Value == 400 /* expired */)
-        {
-            return SendingInterval;
-        }
-
-        // exponential back-off.
-        if (Math.Abs(currentSendInterval.TotalSeconds) < 1)
-        {
-            return TimeSpan.FromSeconds(1);
-        }
-
-        double nextIntervalInSeconds = Math.Min(currentSendInterval.TotalSeconds * 2, maxInterval.TotalSeconds);
-
-        return TimeSpan.FromSeconds(nextIntervalInSeconds);
-    }
-}
diff --git a/src/Cli/dotnet/Telemetry/PersistenceChannel/SnapshottingCollection.cs b/src/Cli/dotnet/Telemetry/PersistenceChannel/SnapshottingCollection.cs
deleted file mode 100644
index 3e98a0d598a8..000000000000
--- a/src/Cli/dotnet/Telemetry/PersistenceChannel/SnapshottingCollection.cs
+++ /dev/null
@@ -1,95 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable disable
-
-using System.Collections;
-using System.Diagnostics;
-
-namespace Microsoft.DotNet.Cli.Telemetry.PersistenceChannel;
-
-internal abstract class SnapshottingCollection<TItem, TCollection> : ICollection<TItem>
-    where TCollection : class, ICollection<TItem>
-{
-    protected readonly TCollection Collection;
-    protected TCollection snapshot;
-
-    protected SnapshottingCollection(TCollection collection)
-    {
-        Debug.Assert(collection != null, "collection");
-        Collection = collection;
-    }
-
-    public int Count => GetSnapshot().Count;
-
-    public bool IsReadOnly => false;
-
-    public void Add(TItem item)
-    {
-        lock (Collection)
-        {
-            Collection.Add(item);
-            snapshot = default;
-        }
-    }
-
-    public void Clear()
-    {
-        lock (Collection)
-        {
-            Collection.Clear();
-            snapshot = default;
-        }
-    }
-
-    public bool Contains(TItem item)
-    {
-        return GetSnapshot().Contains(item);
-    }
-
-    public void CopyTo(TItem[] array, int arrayIndex)
-    {
-        GetSnapshot().CopyTo(array, arrayIndex);
-    }
-
-    public bool Remove(TItem item)
-    {
-        lock (Collection)
-        {
-            bool removed = Collection.Remove(item);
-            if (removed)
-            {
-                snapshot = default;
-            }
-
-            return removed;
-        }
-    }
-
-    public IEnumerator<TItem> GetEnumerator()
-    {
-        return GetSnapshot().GetEnumerator();
-    }
-
-    IEnumerator IEnumerable.GetEnumerator()
-    {
-        return GetEnumerator();
-    }
-
-    protected abstract TCollection CreateSnapshot(TCollection collection);
-
-    protected TCollection GetSnapshot()
-    {
-        TCollection localSnapshot = snapshot;
-        if (localSnapshot == null)
-        {
-            lock (Collection)
-            {
-                snapshot = CreateSnapshot(Collection);
-                localSnapshot = snapshot;
-            }
-        }
-
-        return localSnapshot;
-    }
-}
diff --git a/src/Cli/dotnet/Telemetry/PersistenceChannel/SnapshottingDictionary.cs b/src/Cli/dotnet/Telemetry/PersistenceChannel/SnapshottingDictionary.cs
deleted file mode 100644
index cc6cc51a1f57..000000000000
--- a/src/Cli/dotnet/Telemetry/PersistenceChannel/SnapshottingDictionary.cs
+++ /dev/null
@@ -1,71 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable disable
-
-namespace Microsoft.DotNet.Cli.Telemetry.PersistenceChannel;
-
-internal class SnapshottingDictionary<TKey, TValue> :
-    SnapshottingCollection<KeyValuePair<TKey, TValue>, IDictionary<TKey, TValue>>, IDictionary<TKey, TValue>
-{
-    public SnapshottingDictionary()
-        : base(new Dictionary<TKey, TValue>())
-    {
-    }
-
-    public ICollection<TKey> Keys => GetSnapshot().Keys;
-
-    public ICollection<TValue> Values => GetSnapshot().Values;
-
-    public TValue this[TKey key]
-    {
-        get => GetSnapshot()[key];
-
-        set
-        {
-            lock (Collection)
-            {
-                Collection[key] = value;
-                snapshot = null;
-            }
-        }
-    }
-
-    public void Add(TKey key, TValue value)
-    {
-        lock (Collection)
-        {
-            Collection.Add(key, value);
-            snapshot = null;
-        }
-    }
-
-    public bool ContainsKey(TKey key)
-    {
-        return GetSnapshot().ContainsKey(key);
-    }
-
-    public bool Remove(TKey key)
-    {
-        lock (Collection)
-        {
-            bool removed = Collection.Remove(key);
-            if (removed)
-            {
-                snapshot = null;
-            }
-
-            return removed;
-        }
-    }
-
-    public bool TryGetValue(TKey key, out TValue value)
-    {
-        return GetSnapshot().TryGetValue(key, out value);
-    }
-
-    protected sealed override IDictionary<TKey, TValue> CreateSnapshot(IDictionary<TKey, TValue> collection)
-    {
-        return new Dictionary<TKey, TValue>(collection);
-    }
-}
diff --git a/src/Cli/dotnet/Telemetry/PersistenceChannel/StorageService.cs b/src/Cli/dotnet/Telemetry/PersistenceChannel/StorageService.cs
deleted file mode 100644
index dc44a0bf3cbb..000000000000
--- a/src/Cli/dotnet/Telemetry/PersistenceChannel/StorageService.cs
+++ /dev/null
@@ -1,352 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable disable
-
-using System.Globalization;
-using Microsoft.ApplicationInsights.Channel;
-using Microsoft.DotNet.Configurer;
-
-namespace Microsoft.DotNet.Cli.Telemetry.PersistenceChannel;
-
-internal sealed class StorageService : BaseStorageService
-{
-    private const string DefaultStorageFolderName = "TelemetryStorageService";
-    private readonly FixedSizeQueue<string> _deletedFilesQueue = new(10);
-
-    private readonly object _peekLockObj = new();
-    private readonly object _storageFolderLock = new();
-    private string _storageDirectoryPath;
-    private string _storageDirectoryPathUsed;
-    private long _storageCountFiles;
-    private bool _storageFolderInitialized;
-    private long _storageSize;
-    private uint _transmissionsDropped;
-
-    /// <summary>
-    ///     Gets the storage's folder name.
-    /// </summary>
-    internal override string StorageDirectoryPath => _storageDirectoryPath;
-
-    /// <summary>
-    ///     Gets the storage folder. If storage folder couldn't be created, null will be returned.
-    /// </summary>
-    private string StorageFolder
-    {
-        get
-        {
-            if (!_storageFolderInitialized)
-            {
-                lock (_storageFolderLock)
-                {
-                    if (!_storageFolderInitialized)
-                    {
-                        try
-                        {
-                            _storageDirectoryPathUsed = _storageDirectoryPath;
-
-                            if (!Directory.Exists(_storageDirectoryPathUsed))
-                            {
-                                Directory.CreateDirectory(_storageDirectoryPathUsed);
-                            }
-                        }
-                        catch (Exception e)
-                        {
-                            _storageDirectoryPathUsed = null;
-                            PersistenceChannelDebugLog.WriteException(e, "Failed to create storage folder");
-                        }
-
-                        _storageFolderInitialized = true;
-                    }
-                }
-            }
-
-            return _storageDirectoryPathUsed;
-        }
-    }
-
-    internal override void Init(string storageDirectoryPath)
-    {
-        PeekedTransmissions = new SnapshottingDictionary<string, string>();
-
-        VerifyOrSetDefaultStorageDirectoryPath(storageDirectoryPath);
-
-        CapacityInBytes = 10 * 1024 * 1024; // 10 MB
-        MaxFiles = 100;
-
-        Task.Run(DeleteObsoleteFiles)
-            .ContinueWith(
-                task =>
-                {
-                    PersistenceChannelDebugLog.WriteException(
-                        task.Exception,
-                        "Storage: Unhandled exception in DeleteObsoleteFiles");
-                },
-                TaskContinuationOptions.OnlyOnFaulted);
-    }
-
-    private void VerifyOrSetDefaultStorageDirectoryPath(string desireStorageDirectoryPath)
-    {
-        if (string.IsNullOrEmpty(desireStorageDirectoryPath))
-        {
-            _storageDirectoryPath = Path.Combine(CliFolderPathCalculator.DotnetUserProfileFolderPath,
-                DefaultStorageFolderName);
-        }
-        else
-        {
-            if (!Path.IsPathRooted(desireStorageDirectoryPath))
-            {
-                throw new ArgumentException($"{nameof(desireStorageDirectoryPath)} need to be rooted (full path)");
-            }
-
-            _storageDirectoryPath = desireStorageDirectoryPath;
-        }
-    }
-
-    /// <summary>
-    ///     Reads an item from the storage. Order is Last-In-First-Out.
-    ///     When the Transmission is no longer needed (it was either sent or failed with a non-retryable error) it should be
-    ///     disposed.
-    /// </summary>
-    internal override StorageTransmission Peek()
-    {
-        IEnumerable<string> files = GetFiles("*.trn", 50);
-
-        lock (_peekLockObj)
-        {
-            foreach (string file in files)
-            {
-                try
-                {
-                    // if a file was peeked before, skip it (wait until it is disposed).  
-                    if (PeekedTransmissions.ContainsKey(file) == false &&
-                        _deletedFilesQueue.Contains(file) == false)
-                    {
-                        // Load the transmission from disk.
-                        StorageTransmission storageTransmissionItem = LoadTransmissionFromFileAsync(file)
-                            .ConfigureAwait(false).GetAwaiter().GetResult();
-
-                        // when item is disposed it should be removed from the peeked list.
-                        storageTransmissionItem.Disposing = item => OnPeekedItemDisposed(file);
-
-                        // add the transmission to the list.
-                        PeekedTransmissions.Add(file, storageTransmissionItem.FullFilePath);
-                        return storageTransmissionItem;
-                    }
-                }
-                catch (Exception e)
-                {
-                    PersistenceChannelDebugLog.WriteException(
-                        e,
-                        "Failed to load an item from the storage. file: {0}",
-                        file);
-                }
-            }
-        }
-
-        return null;
-    }
-
-    internal override void Delete(StorageTransmission item)
-    {
-        try
-        {
-            if (StorageFolder == null)
-            {
-                return;
-            }
-
-            // Initial storage size calculation. 
-            CalculateSize();
-
-            long fileSize = GetSize(item.FileName);
-            File.Delete(Path.Combine(StorageFolder, item.FileName));
-
-            _deletedFilesQueue.Enqueue(item.FileName);
-
-            // calculate size                
-            Interlocked.Add(ref _storageSize, -fileSize);
-            Interlocked.Decrement(ref _storageCountFiles);
-        }
-        catch (IOException e)
-        {
-            PersistenceChannelDebugLog.WriteException(e, "Failed to delete a file. file: {0}", item == null ? "null" : item.FullFilePath);
-        }
-    }
-
-    internal override async Task EnqueueAsync(Transmission transmission)
-    {
-        try
-        {
-            if (transmission == null || StorageFolder == null)
-            {
-                return;
-            }
-
-            // Initial storage size calculation. 
-            CalculateSize();
-
-            if ((ulong)_storageSize >= CapacityInBytes || _storageCountFiles >= MaxFiles)
-            {
-                // if max storage capacity has reached, drop the transmission (but log every 100 lost transmissions). 
-                if (_transmissionsDropped++ % 100 == 0)
-                {
-                    PersistenceChannelDebugLog.WriteLine("Total transmissions dropped: " + _transmissionsDropped);
-                }
-
-                return;
-            }
-
-            // Writes content to a temporary file and only then rename to avoid the Peek from reading the file before it is being written.
-            // Creates the temp file name
-            string tempFileName = Guid.NewGuid().ToString("N");
-
-            // Now that the file got created we can increase the files count
-            Interlocked.Increment(ref _storageCountFiles);
-
-            // Saves transmission to the temp file
-            await SaveTransmissionToFileAsync(transmission, tempFileName).ConfigureAwait(false);
-
-            // Now that the file is written increase storage size. 
-            long temporaryFileSize = GetSize(tempFileName);
-            Interlocked.Add(ref _storageSize, temporaryFileSize);
-
-            // Creates a new file name
-            string now = DateTime.UtcNow.ToString("yyyyMMddHHmmss");
-            string newFileName = string.Format(CultureInfo.InvariantCulture, "{0}_{1}.trn", now, tempFileName);
-
-            // Renames the file
-            File.Move(Path.Combine(StorageFolder, tempFileName), Path.Combine(StorageFolder, newFileName));
-        }
-        catch (Exception e)
-        {
-            PersistenceChannelDebugLog.WriteException(e, "EnqueueAsync");
-        }
-    }
-
-    private async Task SaveTransmissionToFileAsync(Transmission transmission, string file)
-    {
-        try
-        {
-            using (Stream stream = File.OpenWrite(Path.Combine(StorageFolder, file)))
-            {
-                await StorageTransmission.SaveAsync(transmission, stream).ConfigureAwait(false);
-            }
-        }
-        catch (UnauthorizedAccessException)
-        {
-            string message =
-                string.Format(
-                    "Failed to save transmission to file. UnauthorizedAccessException. File path: {0}, FileName: {1}",
-                    StorageFolder, file);
-            PersistenceChannelDebugLog.WriteLine(message);
-            throw;
-        }
-    }
-
-    private async Task<StorageTransmission> LoadTransmissionFromFileAsync(string file)
-    {
-        try
-        {
-            using (Stream stream = File.OpenRead(Path.Combine(StorageFolder, file)))
-            {
-                StorageTransmission storageTransmissionItem =
-                    await StorageTransmission.CreateFromStreamAsync(stream, file).ConfigureAwait(false);
-                return storageTransmissionItem;
-            }
-        }
-        catch (Exception e)
-        {
-            string message =
-                string.Format(
-                    "Failed to load transmission from file. File path: {0}, FileName: {1}, Exception: {2}",
-                    "storageFolderName", file, e);
-            PersistenceChannelDebugLog.WriteLine(message);
-            throw;
-        }
-    }
-
-    /// <summary>
-    ///     Get files from <see cref="storageFolder" />.
-    /// </summary>
-    /// <param name="fileQuery">Define the logic for sorting the files.</param>
-    /// <param name="filterByExtension">Defines a file extension. This method will return only files with this extension.</param>
-    /// <param name="top">
-    ///     Define how many files to return. This can be useful when the directory has a lot of files, in that case
-    ///     GetFilesAsync will have a performance hit.
-    /// </param>
-    private IEnumerable<string> GetFiles(string filterByExtension, int top)
-    {
-        try
-        {
-            if (StorageFolder != null)
-            {
-                return Directory.GetFiles(StorageFolder, filterByExtension).Take(top);
-            }
-        }
-        catch (Exception e)
-        {
-            PersistenceChannelDebugLog.WriteException(e, "Peek failed while get files from storage.");
-        }
-
-        return [];
-    }
-
-    /// <summary>
-    ///     Gets a file's size.
-    /// </summary>
-    private long GetSize(string file)
-    {
-        using (FileStream stream = File.OpenRead(Path.Combine(StorageFolder, file)))
-        {
-            return stream.Length;
-        }
-    }
-
-    /// <summary>
-    ///     Check the storage limits and return true if they reached.
-    ///     Storage limits are defined by the number of files and the total size on disk.
-    /// </summary>
-    private void CalculateSize()
-    {
-        string[] storageFiles = Directory.GetFiles(StorageFolder, "*.*");
-
-        _storageCountFiles = storageFiles.Count();
-
-        long storageSizeInBytes = 0;
-        foreach (string file in storageFiles)
-        {
-            storageSizeInBytes += GetSize(file);
-        }
-
-        _storageSize = storageSizeInBytes;
-    }
-
-    /// <summary>
-    ///     Enqueue is saving a transmission to a file with a guid, and after a successful write operation it renames it to a
-    ///     <c>trn</c> file.
-    ///     A file without a <c>trn</c> extension is ignored by Storage.Peek(), so if a process is taken down before rename
-    ///     happens it will stay on the disk forever.
-    ///     This thread deletes files with the <c>trn</c> extension that exists on disk for more than 5 minutes.
-    /// </summary>
-    private void DeleteObsoleteFiles()
-    {
-        try
-        {
-            IEnumerable<string> files = GetFiles("*.trn", 50);
-            foreach (string file in files)
-            {
-                DateTime creationTime = File.GetCreationTimeUtc(Path.Combine(StorageFolder, file));
-                // if the file is older then 5 minutes - delete it.
-                if (DateTime.UtcNow - creationTime >= TimeSpan.FromMinutes(5))
-                {
-                    File.Delete(Path.Combine(StorageFolder, file));
-                }
-            }
-        }
-        catch (Exception e)
-        {
-            PersistenceChannelDebugLog.WriteException(e, "Failed to delete tmp files.");
-        }
-    }
-}
diff --git a/src/Cli/dotnet/Telemetry/PersistenceChannel/StorageTransmission.cs b/src/Cli/dotnet/Telemetry/PersistenceChannel/StorageTransmission.cs
deleted file mode 100644
index 69b6132f1b9f..000000000000
--- a/src/Cli/dotnet/Telemetry/PersistenceChannel/StorageTransmission.cs
+++ /dev/null
@@ -1,127 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable disable
-
-using System.Globalization;
-using Microsoft.ApplicationInsights.Channel;
-
-namespace Microsoft.DotNet.Cli.Telemetry.PersistenceChannel;
-
-internal class StorageTransmission : Transmission, IDisposable
-{
-    internal Action<StorageTransmission> Disposing;
-
-    protected StorageTransmission(string fullPath, Uri address, byte[] content, string contentType,
-        string contentEncoding)
-        : base(address, content, contentType, contentEncoding)
-    {
-        FullFilePath = fullPath;
-        FileName = Path.GetFileName(fullPath);
-    }
-
-    internal string FileName { get; }
-
-    internal string FullFilePath { get; }
-
-    /// <summary>
-    ///     Disposing the storage transmission.
-    /// </summary>
-    public void Dispose()
-    {
-        Dispose(true);
-        GC.SuppressFinalize(this);
-    }
-
-    /// <summary>
-    ///     Creates a new transmission from the specified <paramref name="stream" />.
-    /// </summary>
-    /// <returns>Return transmission loaded from file; return null if the file is corrupted.</returns>
-    internal static async Task<StorageTransmission> CreateFromStreamAsync(Stream stream, string fileName)
-    {
-        StreamReader reader = new(stream);
-        Uri address = await ReadAddressAsync(reader).ConfigureAwait(false);
-        string contentType = await ReadHeaderAsync(reader, "Content-Type").ConfigureAwait(false);
-        string contentEncoding = await ReadHeaderAsync(reader, "Content-Encoding").ConfigureAwait(false);
-        byte[] content = await ReadContentAsync(reader).ConfigureAwait(false);
-        return new StorageTransmission(fileName, address, content, contentType, contentEncoding);
-    }
-
-    /// <summary>
-    ///     Saves the transmission to the specified <paramref name="stream" />.
-    /// </summary>
-    internal static async Task SaveAsync(Transmission transmission, Stream stream)
-    {
-        StreamWriter writer = new(stream);
-        try
-        {
-            await writer.WriteLineAsync(transmission.EndpointAddress.ToString()).ConfigureAwait(false);
-            await writer.WriteLineAsync("Content-Type" + ":" + transmission.ContentType).ConfigureAwait(false);
-            await writer.WriteLineAsync("Content-Encoding" + ":" + transmission.ContentEncoding)
-                .ConfigureAwait(false);
-            await writer.WriteLineAsync(string.Empty).ConfigureAwait(false);
-            await writer.WriteAsync(Convert.ToBase64String(transmission.Content)).ConfigureAwait(false);
-        }
-        finally
-        {
-            writer.Flush();
-        }
-    }
-
-    private static async Task<string> ReadHeaderAsync(TextReader reader, string headerName)
-    {
-        string line = await reader.ReadLineAsync().ConfigureAwait(false);
-        if (string.IsNullOrEmpty(line))
-        {
-            throw new FormatException(string.Format(CultureInfo.InvariantCulture, "{0} header is expected.",
-                headerName));
-        }
-
-        string[] parts = line.Split(':');
-        if (parts.Length != 2)
-        {
-            throw new FormatException(string.Format(CultureInfo.InvariantCulture,
-                "Unexpected header format. {0} header is expected. Actual header: {1}", headerName, line));
-        }
-
-        if (parts[0] != headerName)
-        {
-            throw new FormatException(string.Format(CultureInfo.InvariantCulture,
-                "{0} header is expected. Actual header: {1}", headerName, line));
-        }
-
-        return parts[1].Trim();
-    }
-
-    private static async Task<Uri> ReadAddressAsync(TextReader reader)
-    {
-        string addressLine = await reader.ReadLineAsync().ConfigureAwait(false);
-        if (string.IsNullOrEmpty(addressLine))
-        {
-            throw new FormatException("Transmission address is expected.");
-        }
-
-        Uri address = new(addressLine);
-        return address;
-    }
-
-    private static async Task<byte[]> ReadContentAsync(TextReader reader)
-    {
-        string content = await reader.ReadToEndAsync().ConfigureAwait(false);
-        if (string.IsNullOrEmpty(content) || content == Environment.NewLine)
-        {
-            throw new FormatException("Content is expected.");
-        }
-
-        return Convert.FromBase64String(content);
-    }
-
-    private void Dispose(bool disposing)
-    {
-        if (disposing)
-        {
-            Action<StorageTransmission> disposingDelegate = Disposing;
-            disposingDelegate?.Invoke(this);
-        }
-    }
-}
diff --git a/src/Cli/dotnet/Telemetry/Telemetry.cs b/src/Cli/dotnet/Telemetry/Telemetry.cs
index d9c3a59bd8a1..784f672059ca 100644
--- a/src/Cli/dotnet/Telemetry/Telemetry.cs
+++ b/src/Cli/dotnet/Telemetry/Telemetry.cs
@@ -3,109 +3,84 @@
 
 using System.Collections.Frozen;
 using System.Diagnostics;
-using Microsoft.ApplicationInsights;
-using Microsoft.ApplicationInsights.Extensibility;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.Configurer;
-using CLIRuntimeEnvironment = Microsoft.DotNet.Cli.Utils.RuntimeEnvironment;
 
 namespace Microsoft.DotNet.Cli.Telemetry;
 
 public class Telemetry : ITelemetry
 {
-    internal static string? CurrentSessionId = null;
-    internal static bool DisabledForTests = false;
-    private readonly int _senderCount;
-    private TelemetryClient? _client = null;
-    private FrozenDictionary<string, string>? _commonProperties = null;
-    private FrozenDictionary<string, double>? _commonMeasurements = null;
-    private Task? _trackEventTask = null;
-
-    private const string ConnectionString = "InstrumentationKey=74cc1c9e-3e6e-4d05-b3fc-dde9101d0254";
+    internal static string? s_currentSessionId = null;
+    internal static bool s_disabledForTests = false;
+    private static FrozenDictionary<string, object?> s_commonProperties = null!;
+    private Task? _trackEventTask;
 
+    public static string ConnectionString { get; } = "InstrumentationKey=74cc1c9e-3e6e-4d05-b3fc-dde9101d0254";
+    public static string DefaultStorageFolderName { get; } = "TelemetryStorageService";
     public bool Enabled { get; }
 
     public Telemetry() : this(null) { }
 
-    public Telemetry(IFirstTimeUseNoticeSentinel? sentinel) : this(sentinel, null) { }
-
-    public Telemetry(
-        IFirstTimeUseNoticeSentinel? sentinel,
-        string? sessionId,
-        bool blockThreadInitialization = false,
-        IEnvironmentProvider? environmentProvider = null,
-        int senderCount = 3)
+    public Telemetry(string? sessionId, IEnvironmentProvider? environmentProvider = null)
     {
-
-        if (DisabledForTests)
+        if (s_disabledForTests)
         {
             return;
         }
 
         environmentProvider ??= new EnvironmentProvider();
-
-        Enabled = !environmentProvider.GetEnvironmentVariableAsBool(EnvironmentVariableNames.TELEMETRY_OPTOUT, defaultValue: CompileOptions.TelemetryOptOutDefault)
-                    && PermissionExists(sentinel);
-
+        Enabled = !environmentProvider.GetEnvironmentVariableAsBool(EnvironmentVariableNames.TELEMETRY_OPTOUT, defaultValue: CompileOptions.TelemetryOptOutDefault);
         if (!Enabled)
         {
             return;
         }
 
         // Store the session ID in a static field so that it can be reused
-        CurrentSessionId = sessionId ?? Guid.NewGuid().ToString();
-        _senderCount = senderCount;
-        if (blockThreadInitialization)
+        if (!string.IsNullOrEmpty(sessionId))
         {
-            InitializeTelemetry();
+            s_currentSessionId = sessionId;
         }
         else
         {
-            //initialize in task to offload to parallel thread
-            _trackEventTask = Task.Run(() => InitializeTelemetry());
+            // Generate a new session ID if not provided
+            s_currentSessionId ??= Guid.NewGuid().ToString();
         }
+
+        s_commonProperties = new TelemetryCommonProperties().GetTelemetryCommonProperties(s_currentSessionId);
     }
 
     internal static void DisableForTests()
     {
-        DisabledForTests = true;
-        CurrentSessionId = null;
+        s_disabledForTests = true;
+        s_currentSessionId = null;
     }
 
     internal static void EnableForTests()
     {
-        DisabledForTests = false;
+        s_disabledForTests = false;
     }
 
-    private static bool PermissionExists(IFirstTimeUseNoticeSentinel? sentinel)
+    public void TrackEvent(
+        string? eventName,
+        IDictionary<string, string?>? properties,
+        IDictionary<string, double>? measurements)
     {
-        if (sentinel == null)
+        if (!Enabled)
         {
-            return false;
+            return;
         }
-
-        return sentinel.Exists();
-    }
-
-    public void TrackEvent(string eventName, IDictionary<string, string> properties,
-        IDictionary<string, double> measurements)
-    {
-        if (!Enabled)
+        if (eventName is null)
         {
             return;
         }
 
-        //continue the task in different threads
+        // Continue the task in different threads.
         if (_trackEventTask == null)
         {
             _trackEventTask = Task.Run(() => TrackEventTask(eventName, properties, measurements));
-            return;
         }
         else
         {
-            _trackEventTask = _trackEventTask.ContinueWith(
-                x => TrackEventTask(eventName, properties, measurements)
-            );
+            _trackEventTask = _trackEventTask.ContinueWith(_ => TrackEventTask(eventName, properties, measurements));
         }
     }
 
@@ -119,145 +94,72 @@ public void Flush()
         _trackEventTask.Wait();
     }
 
-    // Adding dispose on graceful shutdown per https://github.com/microsoft/ApplicationInsights-dotnet/issues/1152#issuecomment-518742922
-    public void Dispose()
+    public void ThreadBlockingTrackEvent(string? eventName, IDictionary<string, string?>? properties, IDictionary<string, double>? measurements)
     {
-        if (_client != null)
+        if (!Enabled)
         {
-            _client.TelemetryConfiguration.Dispose();
-            _client = null;
+            return;
         }
-    }
-
-    public void ThreadBlockingTrackEvent(string eventName, IDictionary<string, string> properties, IDictionary<string, double> measurements)
-    {
-        if (!Enabled)
+        if (eventName is null)
         {
             return;
         }
         TrackEventTask(eventName, properties, measurements);
     }
 
-    private void InitializeTelemetry()
+    private static void TrackEventTask(string eventName, IDictionary<string, string?>? properties, IDictionary<string, double>? measurements)
     {
         try
         {
-            var persistenceChannel = new PersistenceChannel.PersistenceChannel(sendersCount: _senderCount)
-            {
-                SendingInterval = TimeSpan.FromMilliseconds(1)
-            };
-
-            var config = TelemetryConfiguration.CreateDefault();
-            config.TelemetryChannel = persistenceChannel;
-            config.ConnectionString = ConnectionString;
-            _client = new TelemetryClient(config);
-            _client.Context.Session.Id = CurrentSessionId;
-            _client.Context.Device.OperatingSystem = CLIRuntimeEnvironment.OperatingSystem;
-
-            _commonProperties = new TelemetryCommonProperties().GetTelemetryCommonProperties(CurrentSessionId);
-            _commonMeasurements = FrozenDictionary<string, double>.Empty;
+            Activity.Current?.AddEvent(CreateActivityEvent(PrependProducerNamespace(eventName), properties, measurements));
         }
         catch (Exception e)
         {
-            _client = null;
-            // we dont want to fail the tool if telemetry fails.
             Debug.Fail(e.ToString());
         }
     }
 
-    private void TrackEventTask(
-        string eventName,
-        IDictionary<string, string> properties,
-        IDictionary<string, double> measurements)
-    {
-        if (_client == null)
-        {
-            return;
-        }
-
-        try
-        {
-            var eventProperties = GetEventProperties(properties);
-            var eventMeasurements = GetEventMeasures(measurements);
-
-            eventProperties ??= new Dictionary<string, string>();
-            eventProperties.Add("event id", Guid.NewGuid().ToString());
-
-            _client.TrackEvent(PrependProducerNamespace(eventName), eventProperties, eventMeasurements);
-            Activity.Current?.AddEvent(CreateActivityEvent(eventName, eventProperties, eventMeasurements));
-        }
-        catch (Exception e)
-        {
-            Debug.Fail(e.ToString());
-        }
-    }
+    private static string PrependProducerNamespace(string eventName) => $"dotnet/cli/{eventName}";
 
     private static ActivityEvent CreateActivityEvent(
         string eventName,
-        IDictionary<string, string>? properties,
+        IDictionary<string, string?>? properties,
         IDictionary<string, double>? measurements)
     {
         var tags = MakeTags(properties, measurements);
-        return new ActivityEvent(
-            PrependProducerNamespace(eventName),
-            tags: tags);
+        return new ActivityEvent(eventName, tags: tags);
     }
 
-    private static ActivityTagsCollection? MakeTags(
-        IDictionary<string, string>? properties,
-        IDictionary<string, double>? measurements)
+    private static ActivityTagsCollection MakeTags(IDictionary<string, string?>? eventProperties, IDictionary<string, double>? eventMeasurements)
     {
-        if (properties == null && measurements == null)
+        var tags = new ActivityTagsCollection
+        (
+            s_commonProperties
+        );
+        if (s_currentSessionId is not null)
         {
-            return null;
+            tags.Add("sessionId", s_currentSessionId);
         }
-        else if (properties != null && measurements == null)
+        if (eventProperties is not null)
         {
-            return [.. properties.Select(p => new KeyValuePair<string, object?>(p.Key, p.Value))];
-        }
-        else if (properties == null && measurements != null)
-        {
-            return [.. measurements.Select(m => new KeyValuePair<string, object?>(m.Key, m.Value.ToString()))];
+            foreach (var property in eventProperties)
+            {
+                if (property.Value is null)
+                {
+                    continue; // Skip null properties
+                }
+                tags.TryAdd(property.Key, property.Value);
+            }
         }
-        else return [ .. properties!.Select(p => new KeyValuePair<string, object?>(p.Key, p.Value)),
-                 .. measurements!.Select(m => new KeyValuePair<string, object?>(m.Key, m.Value.ToString())) ];
-    }
 
-    private static string PrependProducerNamespace(string eventName) => $"dotnet/cli/{eventName}";
-
-    private IDictionary<string, double>? GetEventMeasures(IDictionary<string, double>? measurements)
-    {
-        return (measurements, _commonMeasurements) switch
+        if (eventMeasurements is not null)
         {
-            (null, null) => null,
-            (null, not null) => _commonMeasurements == FrozenDictionary<string, double>.Empty ? null : new Dictionary<string, double>(_commonMeasurements),
-            (not null, null) => measurements,
-            (not null, not null) => Combine(_commonMeasurements, measurements),
-        };
-    }
+            foreach (var measurement in eventMeasurements)
+            {
+                tags.TryAdd(measurement.Key, measurement.Value);
+            }
+        }
 
-    private IDictionary<string, string>? GetEventProperties(IDictionary<string, string>? properties)
-    {
-        return (properties, _commonProperties) switch
-        {
-            (null, null) => null,
-            (null, not null) => _commonProperties == FrozenDictionary<string, string>.Empty ? null : new Dictionary<string, string>(_commonProperties),
-            (not null, null) => properties,
-            (not null, not null) => Combine(_commonProperties, properties),
-        };
+        return tags;
     }
-
-    static IDictionary<TKey, TValue> Combine<TKey, TValue>(IDictionary<TKey, TValue> common, IDictionary<TKey, TValue> specific) where TKey : notnull
-    {
-        IDictionary<TKey, TValue> eventMeasurements = new Dictionary<TKey, TValue>(capacity: common.Count + specific.Count);
-        foreach (KeyValuePair<TKey, TValue> measurement in common)
-        {
-            eventMeasurements[measurement.Key] = measurement.Value;
-        }
-        foreach (KeyValuePair<TKey, TValue> measurement in specific)
-        {
-            eventMeasurements[measurement.Key] = measurement.Value;
-        }
-            return eventMeasurements;
-        }
 }
diff --git a/src/Cli/dotnet/Telemetry/TelemetryCommonProperties.cs b/src/Cli/dotnet/Telemetry/TelemetryCommonProperties.cs
index 625e343d7589..bc280f48476d 100644
--- a/src/Cli/dotnet/Telemetry/TelemetryCommonProperties.cs
+++ b/src/Cli/dotnet/Telemetry/TelemetryCommonProperties.cs
@@ -1,8 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System.Collections.Frozen;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.Configurer;
@@ -12,14 +10,14 @@
 namespace Microsoft.DotNet.Cli.Telemetry;
 
 internal class TelemetryCommonProperties(
-    Func<string> getCurrentDirectory = null,
-    Func<string, string> hasher = null,
-    Func<string> getMACAddress = null,
-    Func<string> getDeviceId = null,
-    IDockerContainerDetector dockerContainerDetector = null,
-    IUserLevelCacheWriter userLevelCacheWriter = null,
-    ICIEnvironmentDetector ciEnvironmentDetector = null,
-    ILLMEnvironmentDetector llmEnvironmentDetector = null)
+    Func<string>? getCurrentDirectory = null,
+    Func<string, string>? hasher = null,
+    Func<string>? getMACAddress = null,
+    Func<string>? getDeviceId = null,
+    IDockerContainerDetector? dockerContainerDetector = null,
+    IUserLevelCacheWriter? userLevelCacheWriter = null,
+    ICIEnvironmentDetector? ciEnvironmentDetector = null,
+    ILLMEnvironmentDetector? llmEnvironmentDetector = null)
 {
     private readonly IDockerContainerDetector _dockerContainerDetector = dockerContainerDetector ?? new DockerContainerDetectorForTelemetry();
     private readonly ICIEnvironmentDetector _ciEnvironmentDetector = ciEnvironmentDetector ?? new CIEnvironmentDetectorForTelemetry();
@@ -52,14 +50,12 @@ internal class TelemetryCommonProperties(
     private const string LLM = "llm";
 
     private const string TelemetryProfileEnvironmentVariable = "DOTNET_CLI_TELEMETRY_PROFILE";
-    private const string CannotFindMacAddress = "Unknown";
-
     private const string MachineIdCacheKey = "MachineId";
     private const string IsDockerContainerCacheKey = "IsDockerContainer";
 
-    public FrozenDictionary<string, string> GetTelemetryCommonProperties(string currentSessionId)
+    public FrozenDictionary<string, object?> GetTelemetryCommonProperties(string currentSessionId)
     {
-        return new Dictionary<string, string>
+        return new Dictionary<string, object?>
         {
             {OSVersion, RuntimeEnvironment.OperatingSystemVersion},
             {OSPlatform, RuntimeEnvironment.OperatingSystemPlatform.ToString()},
@@ -74,8 +70,7 @@ public FrozenDictionary<string, string> GetTelemetryCommonProperties(string curr
             {CurrentPathHash, _hasher(_getCurrentDirectory())},
             {MachineIdOld, _userLevelCacheWriter.RunWithCache(MachineIdCacheKey, GetMachineId)},
             // we don't want to recalcuate a new id for every new SDK version. Reuse the same path across versions.
-            // If we change the format of the cache later.
-            // We need to rename the cache from v1 to v2
+            // If we change the format of the cache later, we need to rename the cache from v1 to v2.
             {MachineId,
                 _userLevelCacheWriter.RunWithCacheInFilePath(
                     Path.Combine(
@@ -94,15 +89,12 @@ public FrozenDictionary<string, string> GetTelemetryCommonProperties(string curr
 
     private string GetMachineId()
     {
-        var macAddress = _getMACAddress();
-        if (macAddress != null)
+        if (_getMACAddress() is { } macAddress)
         {
             return _hasher(macAddress);
         }
-        else
-        {
-            return Guid.NewGuid().ToString();
-        }
+
+        return Guid.NewGuid().ToString();
     }
 
     /// <summary>
@@ -139,8 +131,5 @@ private string GetMachineId()
     ///     Windows.7        Microsoft Windows 6.1.7601 S
     ///     Windows.81       Microsoft Windows 6.3.9600
     /// </summary>
-    private static string GetKernelVersion()
-    {
-        return RuntimeInformation.OSDescription;
-    }
+    private static string GetKernelVersion() => RuntimeInformation.OSDescription;
 }
diff --git a/src/Cli/dotnet/dotnet.csproj b/src/Cli/dotnet/dotnet.csproj
index b05ce4c3dc0f..cff3499e0005 100644
--- a/src/Cli/dotnet/dotnet.csproj
+++ b/src/Cli/dotnet/dotnet.csproj
@@ -52,6 +52,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="Azure.Monitor.OpenTelemetry.Exporter" />
     <PackageReference Include="Microsoft.Extensions.FileSystemGlobbing" />
     <PackageReference Include="Microsoft.VisualStudio.SolutionPersistence" />
     <PackageReference Include="Newtonsoft.Json" />
@@ -60,6 +61,9 @@
     <PackageReference Include="Microsoft.Build" />
     <PackageReference Include="Microsoft.NET.HostModel" />
     <PackageReference Include="Microsoft.TemplateEngine.Orchestrator.RunnableProjects" />
+    <PackageReference Include="OpenTelemetry.Exporter.OpenTelemetryProtocol" />
+    <PackageReference Include="OpenTelemetry.Instrumentation.Http" />
+    <PackageReference Include="OpenTelemetry.Instrumentation.Runtime" />
     <PackageReference Include="System.CommandLine" />
     <PackageReference Include="Microsoft.Deployment.DotNet.Releases" />
     <PackageReference Include="System.ServiceProcess.ServiceController" />
diff --git a/src/Microsoft.DotNet.TemplateLocator/TemplateLocator.cs b/src/Microsoft.DotNet.TemplateLocator/TemplateLocator.cs
index 7ff2785a7b79..653b5608bafd 100644
--- a/src/Microsoft.DotNet.TemplateLocator/TemplateLocator.cs
+++ b/src/Microsoft.DotNet.TemplateLocator/TemplateLocator.cs
@@ -36,8 +36,8 @@ public TemplateLocator(Func<string, string?> getEnvironmentVariable, Func<string
         }
 
         public IReadOnlyCollection<IOptionalSdkTemplatePackageInfo> GetDotnetSdkTemplatePackages(
-            string sdkVersion,
-            string dotnetRootPath,
+            string? sdkVersion,
+            string? dotnetRootPath,
             string? userProfileDir)
         {
             if (string.IsNullOrWhiteSpace(sdkVersion))
@@ -47,8 +47,7 @@ public IReadOnlyCollection<IOptionalSdkTemplatePackageInfo> GetDotnetSdkTemplate
 
             if (string.IsNullOrWhiteSpace(dotnetRootPath))
             {
-                throw new ArgumentException($"'{nameof(dotnetRootPath)}' cannot be null or whitespace",
-                    nameof(dotnetRootPath));
+                throw new ArgumentException($"'{nameof(dotnetRootPath)}' cannot be null or whitespace", nameof(dotnetRootPath));
             }
 
             //  Will the current directory correspond to the folder we are creating a project in?  If we need
diff --git a/test/dotnet.Tests/CommandTests/MSBuild/DotnetMsbuildInProcTests.cs b/test/dotnet.Tests/CommandTests/MSBuild/DotnetMsbuildInProcTests.cs
index a2a26316e3d8..1ea353b3443b 100644
--- a/test/dotnet.Tests/CommandTests/MSBuild/DotnetMsbuildInProcTests.cs
+++ b/test/dotnet.Tests/CommandTests/MSBuild/DotnetMsbuildInProcTests.cs
@@ -54,7 +54,7 @@ private string[] GetArgsForMSBuild(Func<bool> sentinelExists, out Telemetry.Tele
         {
 
             Telemetry.Telemetry.DisableForTests(); // reset static session id modified by telemetry constructor
-            telemetry = new Telemetry.Telemetry(new MockFirstTimeUseNoticeSentinel(sentinelExists));
+            telemetry = new Telemetry.Telemetry();
 
             MSBuildForwardingApp msBuildForwardingApp = new(Enumerable.Empty<string>());
 
diff --git a/test/dotnet.Tests/ConfigurerTests/GivenADotnetFirstTimeUseConfigurerWIthStateSetup.cs b/test/dotnet.Tests/ConfigurerTests/GivenADotnetFirstTimeUseConfigurerWIthStateSetup.cs
index d694240d865b..2acbea846d53 100644
--- a/test/dotnet.Tests/ConfigurerTests/GivenADotnetFirstTimeUseConfigurerWIthStateSetup.cs
+++ b/test/dotnet.Tests/ConfigurerTests/GivenADotnetFirstTimeUseConfigurerWIthStateSetup.cs
@@ -252,10 +252,7 @@ private Telemetry RunConfigUsingMocks(bool isInstallerRun)
 
             configurer.Configure();
 
-            return new Telemetry(firstTimeUseNoticeSentinel,
-                "test",
-                environmentProvider: _environmentProviderObject,
-                senderCount: 0);
+            return new Telemetry("test", environmentProvider: _environmentProviderObject);
         }
 
         private class MockBasicSentinel : IFileSentinel, IFirstTimeUseNoticeSentinel, IAspNetCertificateSentinel
diff --git a/test/dotnet.Tests/TelemetryCommandTest.cs b/test/dotnet.Tests/TelemetryCommandTest.cs
index 8d31a917db13..3e7a27e090e8 100644
--- a/test/dotnet.Tests/TelemetryCommandTest.cs
+++ b/test/dotnet.Tests/TelemetryCommandTest.cs
@@ -56,7 +56,7 @@ public void TopLevelCommandNameShouldBeSentToTelemetry()
         public void TopLevelCommandNameShouldBeSentToTelemetryWithPerformanceData()
         {
             string[] args = { "help" };
-            Cli.Program.ProcessArgs(args, new TimeSpan(12345));
+            Cli.Program.ProcessArgs(args);
 
             _fakeTelemetry.LogEntries.Should().Contain(e => e.EventName == "toplevelparser/command" &&
                               e.Properties.ContainsKey("verb") &&
@@ -85,7 +85,7 @@ public void TopLevelCommandNameShouldBeSentToTelemetryWithoutStartupTime()
         public void TopLevelCommandNameShouldBeSentToTelemetryZeroStartupTime()
         {
             string[] args = { "help" };
-            Cli.Program.ProcessArgs(args, new TimeSpan(0));
+            Cli.Program.ProcessArgs(args);
 
             _fakeTelemetry.LogEntries.Should().Contain(e => e.EventName == "toplevelparser/command" &&
                               e.Properties.ContainsKey("verb") &&
@@ -115,7 +115,7 @@ public void DotnetNewCommandFirstArgumentShouldBeSentToTelemetryWithPerformanceD
         {
             const string argumentToSend = "console";
             string[] args = { "new", argumentToSend };
-            Cli.Program.ProcessArgs(args, new TimeSpan(23456));
+            Cli.Program.ProcessArgs(args);
             _fakeTelemetry
                 .LogEntries.Should()
                 .Contain(e => e.EventName == "sublevelparser/command" &&
@@ -272,7 +272,7 @@ public void AnyDotnetCommandVerbosityOpinionShouldBeSentToTelemetryWithPerforman
             const string optionKey = "verbosity";
             const string optionValueToSend = "minimal";
             string[] args = { "restore", "--" + optionKey, optionValueToSend };
-            Cli.Program.ProcessArgs(args, new TimeSpan(34567));
+            Cli.Program.ProcessArgs(args);
             _fakeTelemetry
                 .LogEntries.Should()
                 .Contain(e => e.EventName == "sublevelparser/command" &&
diff --git a/test/dotnet.Tests/TelemetryCommonPropertiesTests.cs b/test/dotnet.Tests/TelemetryCommonPropertiesTests.cs
index ae1ced7c696d..01fc34952c5e 100644
--- a/test/dotnet.Tests/TelemetryCommonPropertiesTests.cs
+++ b/test/dotnet.Tests/TelemetryCommonPropertiesTests.cs
@@ -39,26 +39,24 @@ public void TelemetryCommonPropertiesShouldReturnDevDeviceId()
             var unitUnderTest = new TelemetryCommonProperties(getDeviceId: () => "plaintext", userLevelCacheWriter: new NothingCache());
             unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["devdeviceid"].Should().Be("plaintext");
         }
-
         [Fact]
         public void TelemetryCommonPropertiesShouldReturnNewGuidWhenCannotGetMacAddress()
         {
             var unitUnderTest = new TelemetryCommonProperties(getMACAddress: () => null, userLevelCacheWriter: new NothingCache());
             var assignedMachineId = unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["Machine ID"];
 
-            Guid.TryParse(assignedMachineId, out var _).Should().BeTrue("it should be a guid");
+            Guid.TryParse((string)assignedMachineId, out var _).Should().BeTrue("it should be a guid");
         }
-
         [Fact]
         public void TelemetryCommonPropertiesShouldEnsureDevDeviceIDIsCached()
         {
             var unitUnderTest = new TelemetryCommonProperties(userLevelCacheWriter: new NothingCache());
             var assignedMachineId = unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["devdeviceid"];
 
-            Guid.TryParse(assignedMachineId, out var _).Should().BeTrue("it should be a guid");
+            Guid.TryParse((string)assignedMachineId, out var _).Should().BeTrue("it should be a guid");
             var secondAssignedMachineId = unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["devdeviceid"];
 
-            Guid.TryParse(secondAssignedMachineId, out var _).Should().BeTrue("it should be a guid");
+            Guid.TryParse((string)secondAssignedMachineId, out var _).Should().BeTrue("it should be a guid");
             secondAssignedMachineId.Should().Be(assignedMachineId, "it should match the previously assigned guid");
         }
 
@@ -68,14 +66,13 @@ public void TelemetryCommonPropertiesShouldReturnHashedMachineIdOld()
             var unitUnderTest = new TelemetryCommonProperties(getMACAddress: () => "plaintext", userLevelCacheWriter: new NothingCache());
             unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["Machine ID Old"].Should().NotBe("plaintext");
         }
-
         [Fact]
         public void TelemetryCommonPropertiesShouldReturnNewGuidWhenCannotGetMacAddressOld()
         {
             var unitUnderTest = new TelemetryCommonProperties(getMACAddress: () => null, userLevelCacheWriter: new NothingCache());
             var assignedMachineId = unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["Machine ID Old"];
 
-            Guid.TryParse(assignedMachineId, out var _).Should().BeTrue("it should be a guid");
+            Guid.TryParse((string)assignedMachineId, out var _).Should().BeTrue("it should be a guid");
         }
 
         [Fact]
@@ -105,59 +102,52 @@ public void TelemetryCommonPropertiesShouldContainArchitectureInformation()
             var unitUnderTest = new TelemetryCommonProperties(getMACAddress: () => null, userLevelCacheWriter: new NothingCache());
             unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["OS Architecture"].Should().Be(RuntimeInformation.OSArchitecture.ToString());
         }
-
         [WindowsOnlyFact]
         public void TelemetryCommonPropertiesShouldContainWindowsInstallType()
         {
             var unitUnderTest = new TelemetryCommonProperties(getMACAddress: () => null, userLevelCacheWriter: new NothingCache());
-            unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["Installation Type"].Should().NotBeEmpty();
+            unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["Installation Type"].Should().NotBeNull();
         }
-
         [UnixOnlyFact]
         public void TelemetryCommonPropertiesShouldContainEmptyWindowsInstallType()
         {
             var unitUnderTest = new TelemetryCommonProperties(getMACAddress: () => null, userLevelCacheWriter: new NothingCache());
-            unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["Installation Type"].Should().BeEmpty();
+            unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["Installation Type"].Should().BeNull();
         }
-
         [WindowsOnlyFact]
         public void TelemetryCommonPropertiesShouldContainWindowsProductType()
         {
             var unitUnderTest = new TelemetryCommonProperties(getMACAddress: () => null, userLevelCacheWriter: new NothingCache());
-            unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["Product Type"].Should().NotBeEmpty();
+            unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["Product Type"].Should().NotBeNull();
         }
-
         [UnixOnlyFact]
         public void TelemetryCommonPropertiesShouldContainEmptyWindowsProductType()
         {
             var unitUnderTest = new TelemetryCommonProperties(getMACAddress: () => null, userLevelCacheWriter: new NothingCache());
-            unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["Product Type"].Should().BeEmpty();
+            unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["Product Type"].Should().BeNull();
         }
-
         [WindowsOnlyFact]
         public void TelemetryCommonPropertiesShouldContainEmptyLibcReleaseAndVersion()
         {
             var unitUnderTest = new TelemetryCommonProperties(getMACAddress: () => null, userLevelCacheWriter: new NothingCache());
-            unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["Libc Release"].Should().BeEmpty();
-            unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["Libc Version"].Should().BeEmpty();
+            unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["Libc Release"].Should().BeNull();
+            unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["Libc Version"].Should().BeNull();
         }
-
         [MacOsOnlyFact]
         public void TelemetryCommonPropertiesShouldContainEmptyLibcReleaseAndVersion2()
         {
             var unitUnderTest = new TelemetryCommonProperties(getMACAddress: () => null, userLevelCacheWriter: new NothingCache());
-            unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["Libc Release"].Should().BeEmpty();
-            unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["Libc Version"].Should().BeEmpty();
+            unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["Libc Release"].Should().BeNull();
+            unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["Libc Version"].Should().BeNull();
         }
-
         [LinuxOnlyFact]
         public void TelemetryCommonPropertiesShouldContainLibcReleaseAndVersion()
         {
             if (!RuntimeInformation.RuntimeIdentifier.Contains("alpine", StringComparison.OrdinalIgnoreCase))
             {
                 var unitUnderTest = new TelemetryCommonProperties(getMACAddress: () => null, userLevelCacheWriter: new NothingCache());
-                unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["Libc Release"].Should().NotBeEmpty();
-                unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["Libc Version"].Should().NotBeEmpty();
+                unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["Libc Release"].Should().NotBeNull();
+                unitUnderTest.GetTelemetryCommonProperties("dummySessionId")["Libc Version"].Should().NotBeNull();
             }
         }
 
@@ -215,7 +205,7 @@ public void CanDetectLLMStatusForEnvVars(Dictionary<string, string>? envVars, st
                 }
             }
         }
-        
+
         [Theory]
         [InlineData("dummySessionId")]
         [InlineData(null)]
diff --git a/test/dotnet.Tests/TelemetryTests/SenderTests.cs b/test/dotnet.Tests/TelemetryTests/SenderTests.cs
deleted file mode 100644
index 98badac85d21..000000000000
--- a/test/dotnet.Tests/TelemetryTests/SenderTests.cs
+++ /dev/null
@@ -1,184 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable disable
-
-using System.Net;
-using System.Runtime.CompilerServices;
-using Moq;
-
-namespace Microsoft.DotNet.Cli.Telemetry.PersistenceChannel.Tests
-{
-    public class SenderTests : SdkTest
-    {
-        private int _deleteCount;
-
-        private Mock<StorageTransmission> TransmissionMock { get; }
-
-        private Mock<BaseStorageService> StorageBaseMock { get; }
-
-        public SenderTests(ITestOutputHelper log) : base(log)
-        {
-            StorageBaseMock = new Mock<BaseStorageService>();
-            TransmissionMock = new Mock<StorageTransmission>(string.Empty, new Uri("http://some/url"), new byte[] { },
-                string.Empty, string.Empty);
-            _deleteCount = 0;
-            StorageBaseMock.Setup(storage => storage.Delete(It.IsAny<StorageTransmission>()))
-                .Callback(() => _deleteCount++);
-        }
-
-        [Fact]
-        public void WhenServerReturn503TransmissionWillBeRetried()
-        {
-            var Sender = GetSenderUnderTest();
-            int peekCounts = 0;
-
-            // Setup transmission.SendAsync() to throw WebException that has 503 status Code
-            TransmissionMock.Setup(transmission => transmission.SendAsync())
-                .Throws(GenerateWebException((HttpStatusCode)503));
-
-            // Setup Storage.Peek() to return the mocked transmission, and stop the loop after 10 peeks.
-            StorageBaseMock.Setup(storage => storage.Peek())
-                .Returns(TransmissionMock.Object)
-                .Callback(() =>
-                {
-                    if (peekCounts++ == 10)
-                    {
-                        Sender.StopAsync();
-                    }
-                });
-
-            // Act 
-            Sender.SendLoop();
-            _deleteCount.Should().Be(0,
-                "delete is not expected to be called on 503, request is expected to be send forever.");
-        }
-
-        [Fact]
-        public void WhenServerReturn400IntervalWillBe10Seconds()
-        {
-            var Sender = GetSenderUnderTest();
-            int peekCounts = 0;
-
-            // Setup transmission.SendAsync() to throw WebException that has 400 status Code
-            TransmissionMock.Setup(transmission => transmission.SendAsync())
-                .Throws(GenerateWebException((HttpStatusCode)400));
-
-            // Setup Storage.Peek() to return the mocked transmission, and stop the loop after 10 peeks.
-            StorageBaseMock.Setup(storage => storage.Peek())
-                .Returns(TransmissionMock.Object)
-                .Callback(() =>
-                {
-                    if (peekCounts++ == 10)
-                    {
-                        Sender.StopAsync();
-                    }
-                });
-
-            // Cache the interval (it is a parameter passed to the Send method).
-            TimeSpan intervalOnSixIteration = TimeSpan.Zero;
-            Sender.OnSend = interval => intervalOnSixIteration = interval;
-
-            // Act 
-            Sender.SendLoop();
-
-            intervalOnSixIteration.TotalSeconds.Should().Be(5);
-            _deleteCount.Should().Be(10, "400 should not be retried so delete should always be called.");
-        }
-
-        [Fact]
-        public void DisposeDoesNotThrow()
-        {
-            new Sender(StorageBaseMock.Object,
-                    new PersistenceTransmitter(
-                        CreateStorageService(),
-                        3))
-                .Dispose();
-        }
-
-        [Fact]
-        public void WhenServerReturnDnsErrorRequestWillBeRetried()
-        {
-            var Sender = GetSenderUnderTest();
-            int peekCounts = 0;
-
-            // Setup transmission.SendAsync() to throw WebException with ProxyNameResolutionFailure failure
-            WebException webException = new(
-                string.Empty,
-                new Exception(),
-                WebExceptionStatus.ProxyNameResolutionFailure,
-                null);
-            TransmissionMock.Setup(transmission => transmission.SendAsync()).Throws(webException);
-
-            // Setup Storage.Peek() to return the mocked transmission, and stop the loop after 10 peeks.
-            StorageBaseMock.Setup(storage => storage.Peek())
-                .Returns(TransmissionMock.Object)
-                .Callback(() =>
-                {
-                    if (peekCounts++ == 10)
-                    {
-                        Sender.StopAsync();
-                    }
-                });
-
-            // Act 
-            Sender.SendLoop();
-
-            _deleteCount.Should().Be(0,
-                "delete is not expected to be called on Dns errors since it , request is expected to be retried forever.");
-        }
-
-        private WebException GenerateWebException(HttpStatusCode httpStatusCode)
-        {
-            Mock<HttpWebResponse> httpWebResponse = new();
-            httpWebResponse.SetupGet(webResponse => webResponse.StatusCode).Returns(httpStatusCode);
-
-            WebException webException = new(string.Empty, new Exception(), WebExceptionStatus.SendFailure,
-                httpWebResponse.Object);
-
-            return webException;
-        }
-
-        /// <summary>
-        ///     A class that inherits from Sender, to expose its protected methods.
-        /// </summary>
-        internal class SenderUnderTest : Sender
-        {
-            internal Action<TimeSpan> OnSend = nextSendInterval => { };
-
-            internal SenderUnderTest(BaseStorageService storage, PersistenceTransmitter transmitter)
-                : base(storage, transmitter, false)
-            {
-            }
-
-            internal AutoResetEvent IntervalAutoResetEvent => DelayHandler;
-
-            internal new void SendLoop()
-            {
-                base.SendLoop();
-            }
-
-            protected override bool Send(StorageTransmission transmission, ref TimeSpan nextSendInterval)
-            {
-                OnSend(nextSendInterval);
-                DelayHandler.Set();
-                return base.Send(transmission, ref nextSendInterval);
-            }
-        }
-
-        private StorageService CreateStorageService([CallerMemberName] string testName = null)
-        {
-            string tempPath = Path.Combine(_testAssetsManager.CreateTestDirectory("TestStorageService", identifier: testName).Path, Path.GetTempFileName());
-            StorageService storageService = new();
-            storageService.Init(tempPath);
-            return storageService;
-        }
-
-        private SenderUnderTest GetSenderUnderTest([CallerMemberName] string testName = null)
-        {
-            StorageService storageService = CreateStorageService(testName);
-            PersistenceTransmitter transmitter = new(storageService, 0);
-            return new SenderUnderTest(StorageBaseMock.Object, transmitter);
-        }
-    }
-}
diff --git a/test/dotnet.Tests/TelemetryTests/StorageTests.cs b/test/dotnet.Tests/TelemetryTests/StorageTests.cs
deleted file mode 100644
index b5f63831d491..000000000000
--- a/test/dotnet.Tests/TelemetryTests/StorageTests.cs
+++ /dev/null
@@ -1,202 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#nullable disable
-
-using System.Runtime.CompilerServices;
-using Microsoft.ApplicationInsights.Channel;
-using Microsoft.ApplicationInsights.DataContracts;
-using Microsoft.ApplicationInsights.Extensibility.Implementation;
-using IChannelTelemetry = Microsoft.ApplicationInsights.Channel.ITelemetry;
-
-namespace Microsoft.DotNet.Cli.Telemetry.PersistenceChannel.Tests
-{
-    /// <summary>
-    ///     Tests for Storage.
-    /// </summary>
-    /// <remarks>
-    ///     To reduce complexity, there was a design decision to make Storage the file system abstraction layer.
-    ///     That means that Storage knows about the file system types (e.g. IStorageFile or FileInfo).
-    ///     Those types are not easy to mock (even IStorageFile is using extension methods that makes it very hard to mock).
-    ///     Therefore those UnitTests just doesn't mock the file system. Every unit test in <see cref="StorageTests" />
-    ///     reads and writes files to/from the disk.
-    /// </remarks>
-    public class StorageTests : SdkTest
-    {
-        public StorageTests(ITestOutputHelper log) : base(log)
-        {
-        }
-
-        [Fact]
-        public async Task EnqueuedContentIsEqualToPeekedContent()
-        {
-            // Setup
-            StorageService storage = new();
-            storage.Init(GetTemporaryPath());
-            Transmission transmissionToEnqueue = CreateTransmission(new TraceTelemetry("mock_item"));
-
-            // Act
-            await storage.EnqueueAsync(transmissionToEnqueue);
-            StorageTransmission peekedTransmission = storage.Peek();
-
-            // Asserts
-            string enqueuedContent =
-                Encoding.UTF8.GetString(transmissionToEnqueue.Content, 0, transmissionToEnqueue.Content.Length);
-            string peekedContent =
-                Encoding.UTF8.GetString(peekedTransmission.Content, 0, peekedTransmission.Content.Length);
-            enqueuedContent.Should().Be(peekedContent);
-        }
-
-        [Fact]
-        public void DeletedItemIsNotReturnedInCallsToPeek()
-        {
-            // Setup - create a storage with one item
-            StorageService storage = new();
-            storage.Init(GetTemporaryPath());
-            Transmission transmissionToEnqueue = CreateTransmissionAndEnqueueIt(storage);
-
-            // Act
-            StorageTransmission firstPeekedTransmission;
-
-            // if item is not disposed,peek will not return it (regardless of the call to delete). 
-            // So for this test to actually test something, using 'using' is required.  
-            using (firstPeekedTransmission = storage.Peek())
-            {
-                storage.Delete(firstPeekedTransmission);
-            }
-
-            StorageTransmission secondPeekedTransmission = storage.Peek();
-
-            // Asserts            
-            firstPeekedTransmission.Should().NotBeNull();
-            secondPeekedTransmission.Should().BeNull();
-        }
-
-        [Fact]
-        public void PeekedItemIsOnlyReturnedOnce()
-        {
-            // Setup - create a storage with one item
-            StorageService storage = new();
-            storage.Init(GetTemporaryPath());
-
-            Transmission transmissionToEnqueue = CreateTransmissionAndEnqueueIt(storage);
-
-            // Act
-            StorageTransmission firstPeekedTransmission = storage.Peek();
-            StorageTransmission secondPeekedTransmission = storage.Peek();
-
-            // Asserts            
-            firstPeekedTransmission.Should().NotBeNull();
-            secondPeekedTransmission.Should().BeNull();
-        }
-
-        [Fact]
-        public async Task PeekedItemIsReturnedAgainAfterTheItemInTheFirstCallToPeekIsDisposed()
-        {
-            // Setup - create a storage with one item
-            StorageService storage = new();
-            storage.Init(GetTemporaryPath());
-
-            Transmission transmissionToEnqueue = CreateTransmission(new TraceTelemetry("mock_item"));
-            await storage.EnqueueAsync(transmissionToEnqueue);
-
-            // Act
-            StorageTransmission firstPeekedTransmission;
-            using (firstPeekedTransmission = storage.Peek())
-            {
-            }
-
-            StorageTransmission secondPeekedTransmission = storage.Peek();
-
-            // Asserts            
-            firstPeekedTransmission.Should().NotBeNull();
-            secondPeekedTransmission.Should().NotBeNull();
-        }
-
-        [Fact]
-        public void WhenStorageHasTwoItemsThenTwoCallsToPeekReturns2DifferentItems()
-        {
-            // Setup - create a storage with 2 items
-            StorageService storage = new();
-            storage.Init(GetTemporaryPath());
-
-            Transmission firstTransmission = CreateTransmissionAndEnqueueIt(storage);
-            Transmission secondTransmission = CreateTransmissionAndEnqueueIt(storage);
-
-            // Act
-            StorageTransmission firstPeekedTransmission = storage.Peek();
-            StorageTransmission secondPeekedTransmission = storage.Peek();
-
-            // Asserts            
-            firstPeekedTransmission.Should().NotBeNull();
-            secondPeekedTransmission.Should().NotBeNull();
-
-            string first = Encoding.UTF8.GetString(firstPeekedTransmission.Content, 0,
-                firstPeekedTransmission.Content.Length);
-            string second = Encoding.UTF8.GetString(secondPeekedTransmission.Content, 0,
-                secondPeekedTransmission.Content.Length);
-            first.Should().NotBe(second);
-        }
-
-        [Fact]
-        public void WhenMaxFilesIsOneThenSecondTransmissionIsDropped()
-        {
-            // Setup
-            StorageService storage = new();
-            storage.Init(GetTemporaryPath());
-
-            storage.MaxFiles = 1;
-
-            // Act - Enqueue twice
-            CreateTransmissionAndEnqueueIt(storage);
-            CreateTransmissionAndEnqueueIt(storage);
-
-            // Asserts - Second Peek should be null 
-            storage.Peek().Should().NotBeNull();
-            storage.Peek().Should().BeNull();
-        }
-
-        [Fact]
-        public void WhenMaxSizeIsReachedThenEnqueuedTransmissionsAreDropped()
-        {
-            // Setup - create a storage with 2 items
-            StorageService storage = new();
-            storage.Init(GetTemporaryPath());
-
-            storage.CapacityInBytes = 200; // Each file enqueued in CreateTransmissionAndEnqueueIt is ~300 bytes.
-
-            // Act - Enqueue twice
-            CreateTransmissionAndEnqueueIt(storage);
-            CreateTransmissionAndEnqueueIt(storage);
-
-            // Asserts - Second Peek should be null 
-            storage.Peek().Should().NotBeNull();
-            storage.Peek().Should().BeNull();
-        }
-
-        private static Transmission CreateTransmission(IChannelTelemetry telemetry)
-        {
-            byte[] data = JsonSerializer.Serialize(new[] { telemetry });
-            Transmission transmission = new(
-                new Uri(@"http://some.url"),
-                data,
-                "application/x-json-stream",
-                JsonSerializer.CompressionType);
-
-            return transmission;
-        }
-
-        private static Transmission CreateTransmissionAndEnqueueIt(StorageService storage)
-        {
-            Transmission firstTransmission = CreateTransmission(new TraceTelemetry(Guid.NewGuid().ToString()));
-            storage.EnqueueAsync(firstTransmission).ConfigureAwait(false).GetAwaiter().GetResult();
-
-            return firstTransmission;
-        }
-
-        private string GetTemporaryPath([CallerMemberName] string callingMethod = null)
-        {
-            return _testAssetsManager.CreateTestDirectory(callingMethod).Path;
-        }
-    }
-}