Add analytics to analyzer-cli and analysis server.

pkg/analyzer_cli/lib/src/driver.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import 'dart:async';
 import 'dart:io' as io;
 
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/file_system/file_system.dart' as file_system;
 import 'package:analyzer/file_system/file_system.dart';
@@ skipping 31 matching lines @@
 import 'package:front_end/src/base/performace_logger.dart';
 import 'package:front_end/src/incremental/byte_store.dart';
 import 'package:linter/src/rules.dart' as linter;
 import 'package:package_config/discovery.dart' as pkg_discovery;
 import 'package:package_config/packages.dart' show Packages;
 import 'package:package_config/packages_file.dart' as pkgfile show parse;
 import 'package:package_config/src/packages_impl.dart' show MapPackages;
 import 'package:path/path.dart' as path;
 import 'package:plugin/manager.dart';
 import 'package:plugin/plugin.dart';
+import 'package:telemetry/crash_reporting.dart';
+import 'package:telemetry/telemetry.dart' as telemetry;
 import 'package:yaml/yaml.dart';
 
 /// Shared IO sink for standard error reporting.
 ///
 /// *Visible for testing.*
 StringSink errorSink = io.stderr;
 
 /// Shared IO sink for standard out reporting.
 ///
 /// *Visible for testing.*
 StringSink outSink = io.stdout;
 
 /// Test this option map to see if it specifies lint rules.
 bool containsLintRuleEntry(Map<String, YamlNode> options) {
   var linterNode = options['linter'];
   return linterNode is YamlMap && linterNode.containsKey('rules');
 }
 
+telemetry.Analytics _analytics;
+
+// TODO(devoncarew): Replace with the real tracking ID.
+const _analyticsID = 'UA-001';
+
+/// The analytics instance for analyzer-cli.
+telemetry.Analytics get analytics => (_analytics ??=
+    telemetry.createAnalyticsInstance(_analyticsID, 'analyzer-cli'));
+
+/// Make sure that we create an analytics instance that doesn't send for this
+/// session.
+void disableAnalyticsForSession() {
+  _analytics = telemetry.createAnalyticsInstance(_analyticsID, 'analyzer-cli',
+      disableForSession: true);
+}
+
+/// Public for testing.

[Brian Wilkerson, 2017/06/30 18:51:22]

Please use the annotation `visibleForTesting` (from the 'meta' package).

[devoncarew, 2017/06/30 21:58:13]

Updated!

+void setAnalyticsMock(telemetry.Analytics replacementAnalytics) {
+  _analytics = replacementAnalytics;
+}
+
 class Driver implements CommandLineStarter {
   static final PerformanceTag _analyzeAllTag =
       new PerformanceTag("Driver._analyzeAll");
 
   /// Cache of [AnalysisOptionsImpl] objects that correspond to directories
   /// with analyzed files, used to reduce searching for `analysis_options.yaml`
   /// files.
   static Map<String, AnalysisOptionsImpl> _directoryToAnalysisOptions = {};
 
   static ByteStore analysisDriverMemoryByteStore = new MemoryByteStore();
@@ skipping 22 matching lines @@
 
   /**
    * The resource provider used to access the file system.
    */
   file_system.ResourceProvider resourceProvider =
       PhysicalResourceProvider.INSTANCE;
 
   /// Collected analysis statistics.
   final AnalysisStats stats = new AnalysisStats();
 
+  CrashReportSender _crashReportSender;
+
+  // TODO(devoncarew): Replace with the real crash product ID.
+  /// The crash reporting instance for analyzer-cli.
+  CrashReportSender get crashReportSender => (_crashReportSender ??=
+      new CrashReportSender('Dart-analyzer-cli', analytics));
+
+  /// Create a new Driver instance.
+  ///
+  /// [isTesting] is true is we're running in a test environment.

[Brian Wilkerson, 2017/06/30 18:51:22]

"true is" --> "true if"

[devoncarew, 2017/06/30 21:58:13]

Done.

+  Driver({bool isTesting: false}) {
+    if (isTesting) {
+      disableAnalyticsForSession();
+    }
+  }
+
   /// This Driver's current analysis context.
   ///
   /// *Visible for testing.*
   AnalysisContext get context => _context;
 
   @override
   void set userDefinedPlugins(List<Plugin> plugins) {
     _userDefinedPlugins = plugins ?? <Plugin>[];
   }
 
   @override
   Future<Null> start(List<String> args) async {
     if (_context != null) {
       throw new StateError("start() can only be called once");
     }
     int startTime = new DateTime.now().millisecondsSinceEpoch;
 
     StringUtilities.INTERNER = new MappedInterner();
 
     _processPlugins();
 
     // Parse commandline options.
     CommandLineOptions options = CommandLineOptions.parse(args);
 
+    if (options.batchMode || options.buildMode) {
+      disableAnalyticsForSession();
+    }
+
+    // Ping analytics with our initial call.
+    analytics.sendScreenView('home');
+
+    var timer = analytics.startTimer('analyze');
+
     // Do analysis.
     if (options.buildMode) {
       ErrorSeverity severity = _buildModeAnalyze(options);
       // Propagate issues to the exit code.
       if (_shouldBeFatal(severity, options)) {
         io.exitCode = severity.ordinal;
       }
-    } else if (options.shouldBatch) {
+    } else if (options.batchMode) {
       BatchRunner batchRunner = new BatchRunner(outSink, errorSink);
       batchRunner.runAsBatch(args, (List<String> args) async {
         CommandLineOptions options = CommandLineOptions.parse(args);
         return await _analyzeAll(options);
       });
     } else {
       ErrorSeverity severity = await _analyzeAll(options);
       // Propagate issues to the exit code.
       if (_shouldBeFatal(severity, options)) {
         io.exitCode = severity.ordinal;
       }
     }
 
     if (_context != null) {
       _analyzedFileCount += _context.sources.length;
     }
 
+    // Send how long analysis took.
+    timer.finish();
+
+    // Send how many files were analyzed.
+    analytics.sendEvent('analyze', 'analyzedFiles', value: _analyzedFileCount);
+
     if (options.perfReport != null) {
       String json = makePerfReport(
           startTime, currentTimeMillis, options, _analyzedFileCount, stats);
       new io.File(options.perfReport).writeAsStringSync(json);
     }
+
+    // Wait a brief time for any analytics calls to finish.
+    await analytics.waitForLastPing(timeout: new Duration(milliseconds: 200));
   }
 
   Future<ErrorSeverity> _analyzeAll(CommandLineOptions options) async {
     PerformanceTag previous = _analyzeAllTag.makeCurrent();
     try {
       return await _analyzeAllImpl(options);
+    } catch (e, st) {
+      crashReportSender.sendReport(e, stackTrace: st);
+      rethrow;
     } finally {
       previous.makeCurrent();
     }
   }
 
   /// Perform analysis according to the given [options].
   Future<ErrorSeverity> _analyzeAllImpl(CommandLineOptions options) async {
     if (!options.machineFormat) {
       List<String> fileNames = options.sourceFiles.map((String file) {
         file = path.normalize(file);
@@ skipping 132 matching lines @@
         return new BuildMode(resourceProvider, options, stats).analyze();
       }
     });
   }
 
   /// Decide on the appropriate policy for which files need to be fully parsed
   /// and which files need to be diet parsed, based on [options], and return an
   /// [AnalyzeFunctionBodiesPredicate] that implements this policy.
   AnalyzeFunctionBodiesPredicate _chooseDietParsingPolicy(
       CommandLineOptions options) {
-    if (options.shouldBatch) {
+    if (options.batchMode) {
       // As analyzer is currently implemented, once a file has been diet
       // parsed, it can't easily be un-diet parsed without creating a brand new
       // context and losing caching.  In batch mode, we can't predict which
       // files we'll need to generate errors and warnings for in the future, so
       // we can't safely diet parse anything.
       return (Source source) => true;
     }
 
     return (Source source) {
       if (options.sourceFiles.contains(source.fullName)) {
@@ skipping 597 matching lines @@
     for (var package in packages) {
       var packageName = path.basename(package.path);
       var realPath = package.resolveSymbolicLinksSync();
       result[packageName] = [
         PhysicalResourceProvider.INSTANCE.getFolder(realPath)
       ];
     }
     return result;
   }
 }