Track local telemetry during remote LSP experimentation for comparison.

src/EditorFeatures/Core/Implementation/Classification/SyntacticClassificationTaggerProvider.TagComputer.cs

@@ -2,6 +2,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Classification;
@@ -9,6 +10,7 @@
 using Microsoft.CodeAnalysis.Editor.Shared.Tagging;
 using Microsoft.CodeAnalysis.Editor.Shared.Threading;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.Experiments;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
@@ -38,6 +40,12 @@ internal partial class TagComputer
             // parsed it yet, and we want to get back to a known state.
             private const int ReportChangeDelayInMilliseconds = TaggerConstants.ShortDelay;
 
+            // TODO - Cleanup once experiment completed - https://github.com/dotnet/roslyn/projects/45#card-27261853
+            // LSP client language names
+            private readonly ImmutableArray<string> _lspClientLanguages = ImmutableArray.Create("C#_LSP", "VB_LSP");
+            // Cache if the LSP experiment is enabled.
+            private bool? _areRemoteClassificationsEnabled;
+
             private readonly ITextBuffer _subjectBuffer;
             private readonly WorkspaceRegistration _workspaceRegistration;
             private readonly AsynchronousSerialWorkQueue _workQueue;
@@ -199,9 +207,20 @@ private async Task EnqueueProcessSnapshotWorkerAsync(Document document, Cancella
                     return;
                 }
 
-                // preemptively parse file in background so that when we are called from tagger from UI thread, we have tree ready.
-                // F#/typescript and other languages that doesn't support syntax tree will return null here.
-                _ = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
+                // TODO - Cleanup once experiment completed - https://github.com/dotnet/roslyn/projects/45#card-27261853
+                if (ShouldLogLocalTelemetry(document.Project.Language))
+                {
+                    using (new RequestLatencyTracker(SyntacticLspLogger.RequestType.SyntacticTagger))
+                    {
+                        _ = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
+                    }
+                }
+                else
+                {
+                    // preemptively parse file in background so that when we are called from tagger from UI thread, we have tree ready.
+                    // F#/typescript and other languages that doesn't support syntax tree will return null here.
+                    _ = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
+                }
 
                 lock (_gate)
                 {
@@ -220,6 +239,22 @@ private async Task EnqueueProcessSnapshotWorkerAsync(Document document, Cancella
                     _reportChangeCancellationSource.Token);
             }
 
+            /// <summary>
+            /// TODO - Cleanup once experiment completed - https://github.com/dotnet/roslyn/projects/45#card-27261853
+            /// Only capture local classification telemetry for experiment when in liveshare and remote classifications are not active.
+            /// </summary>
+            private bool ShouldLogLocalTelemetry(string languageName)
+            {
+                var isLspContentType = _lspClientLanguages.Contains(languageName);
+                if (_areRemoteClassificationsEnabled == null)
+                {
+                    var experimentationService = _workspace.Services.GetService<IExperimentationService>();
+                    _areRemoteClassificationsEnabled = experimentationService.IsExperimentEnabled(WellKnownExperimentNames.SyntacticExp_LiveShareTagger_Remote);
+                }
+
+                return isLspContentType && !(bool)_areRemoteClassificationsEnabled;
+            }
+
             private void ReportChangedSpan(SnapshotSpan changeSpan)
             {
                 lock (_gate)

src/VisualStudio/LiveShare/Impl/Client/Tagger/SyntacticClassificationTaggerProvider.TagComputer.cs

@@ -179,8 +179,7 @@ private async Task EnqueueProcessSnapshotWorkerAsync(DocumentId documentId, Canc
                     return;
                 }
 
-                var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
-                var text = await tree.GetTextAsync(cancellationToken).ConfigureAwait(false);
+                var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
                 var snapshot = text.FindCorrespondingEditorTextSnapshot();
                 if (snapshot == null)
                 {
@@ -188,7 +187,7 @@ private async Task EnqueueProcessSnapshotWorkerAsync(DocumentId documentId, Canc
                 }
 
                 var classifiedSpans = ClassificationUtilities.GetOrCreateClassifiedSpanList();
-                await classificationService.AddRemoteSyntacticClassificationsAsync(document, TextSpan.FromBounds(0, tree.Length), classifiedSpans, cancellationToken).ConfigureAwait(false);
+                await classificationService.AddRemoteSyntacticClassificationsAsync(document, TextSpan.FromBounds(0, text.Length), classifiedSpans, cancellationToken).ConfigureAwait(false);
 
                 using var tagSpans = SharedPools.Default<List<ITagSpan<IClassificationTag>>>().GetPooledObject();
                 ClassificationUtilities.Convert(_typeMap, snapshot, classifiedSpans, tagSpans.Object.Add);

src/VisualStudio/LiveShare/Impl/Client/Classification/RequestLatencyTracker.cs → src/Workspaces/Core/Portable/Log/RequestLatencyTracker.cs

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System;
-using Microsoft.CodeAnalysis.Internal.Log;
 
-namespace Microsoft.VisualStudio.LanguageServices.LiveShare.Client.Classification
+namespace Microsoft.CodeAnalysis.Internal.Log
 {
     internal sealed class RequestLatencyTracker : IDisposable
     {