Only use Visual Studio Telemetry on VS 2017 and above

src/GitHub.VisualStudio.16/CompositionServices.cs

@@ -82,7 +82,7 @@ internal static IUsageTracker CreateUsageTracker(CompositionContainer compositio
                 var gitHubServiceProvider = compositionContainer.GetExportedValue<IGitHubServiceProvider>();
                 var usageService = compositionContainer.GetExportedValue<IUsageService>();
                 var joinableTaskContext = compositionContainer.GetExportedValue<JoinableTaskContext>();
-                return new UsageTracker(gitHubServiceProvider, usageService, packageSettings, joinableTaskContext);
+                return new UsageTracker(gitHubServiceProvider, usageService, packageSettings, joinableTaskContext, vsTelemetry: true);
             }
         }
 

src/GitHub.VisualStudio/GitHub.VisualStudio.csproj

@@ -129,6 +129,7 @@
     <Compile Include="Services\ShowDialogService.cs" />
     <Compile Include="Services\UsageService.cs" />
     <Compile Include="Services\UsageTracker.cs" />
+    <Compile Include="Services\VisualStudioUsageTracker.cs" />
     <Compile Include="Services\VSGitExtFactory.cs" />
     <Compile Include="Settings\Constants.cs" />
     <Compile Include="Services\ConnectionManager.cs" />

src/GitHub.VisualStudio/GitHubPackage.cs

@@ -393,7 +393,13 @@ async Task<object> CreateService(IAsyncServiceContainer container, CancellationT
                 Assumes.Present(serviceProvider);
                 Assumes.Present(settings);
 
-                return new UsageTracker(serviceProvider, usageService, settings, ThreadHelper.JoinableTaskContext);
+                // Only use Visual Studio Telemetry on VS 2017 and above
+                await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+                var dte = await GetServiceAsync(typeof(EnvDTE.DTE)) as EnvDTE.DTE;
+                Assumes.Present(dte);
+                var vsTelemetry = new Version(dte.Version) >= new Version(15, 0);
+
+                return new UsageTracker(serviceProvider, usageService, settings, ThreadHelper.JoinableTaskContext, vsTelemetry);
             }
             else if (serviceType == typeof(IVSGitExt))
             {

src/GitHub.VisualStudio/Services/UsageTracker.cs

@@ -7,8 +7,6 @@
 using GitHub.Logging;
 using GitHub.Models;
 using GitHub.Settings;
-using Microsoft.VisualStudio.Telemetry;
-using Microsoft.VisualStudio.Text.Editor;
 using Microsoft.VisualStudio.Threading;
 using Serilog;
 using Task = System.Threading.Tasks.Task;
@@ -17,25 +15,6 @@ namespace GitHub.Services
 {
     public sealed class UsageTracker : IUsageTracker, IDisposable
     {
-        private const int TelemetryVersion = 1; // Please update the version every time you want to indicate a change in telemetry logic when the extension itself is updated
-
-        private const string EventNamePrefix = "vs/github/usagetracker/";
-        private const string PropertyPrefix = "vs.github.";
-
-        static class Event
-        {
-            public const string UsageTracker = EventNamePrefix + "increment-counter";
-        }
-
-        static class Property
-        {
-            public const string TelemetryVersion = PropertyPrefix + nameof(TelemetryVersion);
-            public const string CounterName = PropertyPrefix + nameof(CounterName);
-            public const string ExtensionVersion = PropertyPrefix + nameof(ExtensionVersion);
-            public const string IsGitHubUser = PropertyPrefix + nameof(IsGitHubUser);
-            public const string IsEnterpriseUser = PropertyPrefix + nameof(IsEnterpriseUser);
-        }
-
         static readonly ILogger log = LogManager.ForContext<UsageTracker>();
         readonly IGitHubServiceProvider gitHubServiceProvider;
 
@@ -44,20 +23,25 @@ static class Property
         readonly IUsageService service;
         IConnectionManager connectionManager;
         readonly IPackageSettings userSettings;
+        readonly bool vsTelemetry;
         IVSServices vsservices;
+        IUsageTracker visualStudioUsageTracker;
         IDisposable timer;
         bool firstTick = true;
 
         public UsageTracker(
             IGitHubServiceProvider gitHubServiceProvider,
             IUsageService service,
             IPackageSettings settings,
-            JoinableTaskContext joinableTaskContext)
+            JoinableTaskContext joinableTaskContext,
+            bool vsTelemetry)
         {
             this.gitHubServiceProvider = gitHubServiceProvider;
             this.service = service;
             this.userSettings = settings;
             JoinableTaskContext = joinableTaskContext;
+            this.vsTelemetry = vsTelemetry;
+
             timer = StartTimer();
         }
 
@@ -77,27 +61,13 @@ public async Task IncrementCounter(Expression<Func<UsageModel.MeasuresModel, int
 
             var updateTask = UpdateUsageMetrics(propertyInfo);
 
-            LogTelemetryEvent(counterName);
-
-            await updateTask;
-        }
-
-        void LogTelemetryEvent(string counterName)
-        {
-            const string numberOfPrefix = "numberof";
-            if (counterName.StartsWith(numberOfPrefix, StringComparison.OrdinalIgnoreCase))
+            if (visualStudioUsageTracker != null)
             {
-                counterName = counterName.Substring(numberOfPrefix.Length);
+                // Not available on Visual Studio 2015
+                await visualStudioUsageTracker.IncrementCounter(counter);
             }
 
-            var operation = new TelemetryEvent(Event.UsageTracker);
-            operation.Properties[Property.TelemetryVersion] = TelemetryVersion;
-            operation.Properties[Property.CounterName] = counterName;
-            operation.Properties[Property.ExtensionVersion] = AssemblyVersionInformation.Version;
-            operation.Properties[Property.IsGitHubUser] = IsGitHubUser;
-            operation.Properties[Property.IsEnterpriseUser] = IsEnterpriseUser;
-
-            TelemetryService.DefaultSession.PostEvent(operation);
+            await updateTask;
         }
 
         bool IsEnterpriseUser =>
@@ -111,7 +81,7 @@ async Task UpdateUsageMetrics(PropertyInfo propertyInfo)
             var data = await service.ReadLocalData();
             var usage = await GetCurrentReport(data);
 
-            var value = (int) propertyInfo.GetValue(usage.Measures);
+            var value = (int)propertyInfo.GetValue(usage.Measures);
             propertyInfo.SetValue(usage.Measures, value + 1);
 
             await service.WriteLocalData(data);
@@ -134,6 +104,13 @@ async Task Initialize()
             client = gitHubServiceProvider.TryGetService<IMetricsService>();
             connectionManager = gitHubServiceProvider.GetService<IConnectionManager>();
             vsservices = gitHubServiceProvider.GetService<IVSServices>();
+
+            if (vsTelemetry)
+            {
+                log.Verbose("Creating VisualStudioUsageTracker");
+                visualStudioUsageTracker = new VisualStudioUsageTracker(connectionManager);
+            }
+
             initialized = true;
         }
 

src/GitHub.VisualStudio/Services/VisualStudioUsageTracker.cs

@@ -0,0 +1,79 @@
+using System;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using GitHub.Models;
+using Microsoft.VisualStudio.Telemetry;
+using Task = System.Threading.Tasks.Task;
+
+namespace GitHub.Services
+{
+    /// <summary>
+    /// Implementation of <see cref="IUsageTracker" /> that uses the built in Visual Studio telemetry.
+    /// </summary>
+    /// <remarks>
+    /// This should only be created on Visual Studio 2017 and above.
+    /// </remarks>
+    public sealed class VisualStudioUsageTracker : IUsageTracker
+    {
+        const int TelemetryVersion = 1; // Please update the version every time you want to indicate a change in telemetry logic when the extension itself is updated
+
+        const string EventNamePrefix = "vs/github/usagetracker/";
+        const string PropertyPrefix = "vs.github.";
+
+        readonly IConnectionManager connectionManager;
+
+        public VisualStudioUsageTracker(IConnectionManager connectionManager)
+        {
+            this.connectionManager = connectionManager;
+        }
+
+        public Task IncrementCounter(Expression<Func<UsageModel.MeasuresModel, int>> counter)
+        {
+            var property = (MemberExpression)counter.Body;
+            var propertyInfo = (PropertyInfo)property.Member;
+            var counterName = propertyInfo.Name;
+            LogTelemetryEvent(counterName);
+
+            return Task.CompletedTask;
+        }
+
+        void LogTelemetryEvent(string counterName)
+        {
+            const string numberOfPrefix = "numberof";
+            if (counterName.StartsWith(numberOfPrefix, StringComparison.OrdinalIgnoreCase))
+            {
+                counterName = counterName.Substring(numberOfPrefix.Length);
+            }
+
+            var operation = new TelemetryEvent(Event.UsageTracker);
+            operation.Properties[Property.TelemetryVersion] = TelemetryVersion;
+            operation.Properties[Property.CounterName] = counterName;
+            operation.Properties[Property.ExtensionVersion] = AssemblyVersionInformation.Version;
+            operation.Properties[Property.IsGitHubUser] = IsGitHubUser;
+            operation.Properties[Property.IsEnterpriseUser] = IsEnterpriseUser;
+
+            TelemetryService.DefaultSession.PostEvent(operation);
+        }
+
+        bool IsEnterpriseUser =>
+            connectionManager?.Connections.Any(x => !x.HostAddress.IsGitHubDotCom()) ?? false;
+
+        bool IsGitHubUser =>
+            connectionManager?.Connections.Any(x => x.HostAddress.IsGitHubDotCom()) ?? false;
+
+        static class Event
+        {
+            public const string UsageTracker = EventNamePrefix + "increment-counter";
+        }
+
+        static class Property
+        {
+            public const string TelemetryVersion = PropertyPrefix + nameof(TelemetryVersion);
+            public const string CounterName = PropertyPrefix + nameof(CounterName);
+            public const string ExtensionVersion = PropertyPrefix + nameof(ExtensionVersion);
+            public const string IsGitHubUser = PropertyPrefix + nameof(IsGitHubUser);
+            public const string IsEnterpriseUser = PropertyPrefix + nameof(IsEnterpriseUser);
+        }
+    }
+}

test/GitHub.VisualStudio.UnitTests/Services/MetricsTests.cs

@@ -24,7 +24,7 @@ public class UsageTrackerTests : TestBaseClass
         public void ShouldStartTimer()
         {
             var service = Substitute.For<IUsageService>();
-            var target = new UsageTracker(CreateServiceProvider(), service, CreatePackageSettings(), new JoinableTaskContext());
+            var target = new UsageTracker(CreateServiceProvider(), service, CreatePackageSettings(), new JoinableTaskContext(), vsTelemetry: false);
 
             service.Received(1).StartTimer(Arg.Any<Func<Task>>(), TimeSpan.FromMinutes(3), TimeSpan.FromDays(1));
         }
@@ -111,7 +111,8 @@ public async Task ShouldIncrementCounter()
                 CreateServiceProvider(),
                 usageService,
                 CreatePackageSettings(),
-                new JoinableTaskContext());
+                new JoinableTaskContext(),
+                vsTelemetry: false);
 
             await target.IncrementCounter(x => x.NumberOfClones);
             UsageData result = usageService.ReceivedCalls().First(x => x.GetMethodInfo().Name == "WriteLocalData").GetArguments()[0] as UsageData;
@@ -128,7 +129,8 @@ public async Task ShouldWriteData()
                 CreateServiceProvider(),
                 service,
                 CreatePackageSettings(),
-                new JoinableTaskContext());
+                new JoinableTaskContext(),
+                vsTelemetry: false);
 
             await target.IncrementCounter(x => x.NumberOfClones);
             await service.Received(1).WriteLocalData(Arg.Is<UsageData>(data => 
@@ -155,7 +157,8 @@ public async Task ShouldWriteUpdatedData()
                 CreateServiceProvider(),
                 service,
                 CreatePackageSettings(),
-                new JoinableTaskContext());
+                new JoinableTaskContext(),
+                vsTelemetry: false);
 
             await target.IncrementCounter(x => x.NumberOfClones);
             await service.Received(1).WriteLocalData(Arg.Is<UsageData>(data =>
@@ -177,7 +180,7 @@ static Tuple<UsageTracker, Func<Task>> CreateTargetAndGetTick(
             service.WhenForAnyArgs(x => x.StartTimer(null, new TimeSpan(), new TimeSpan()))
                 .Do(x => tick = x.ArgAt<Func<Task>>(0));
 
-            var target = new UsageTracker(serviceProvider, service, CreatePackageSettings(), new JoinableTaskContext());
+            var target = new UsageTracker(serviceProvider, service, CreatePackageSettings(), new JoinableTaskContext(), vsTelemetry: false);
 
             return Tuple.Create(target, tick);
         }