Add analytics to analyzer-cli and analysis server.

pkg/analysis_server/lib/src/server/driver.dart

 // Copyright (c) 2014, 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';
 import 'dart:math';
 
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/plugin/server_plugin.dart';
 import 'package:analysis_server/src/provisional/completion/dart/completion_plugin.dart';
 import 'package:analysis_server/src/server/diagnostic_server.dart';
 import 'package:analysis_server/src/server/http_server.dart';
 import 'package:analysis_server/src/server/stdio_server.dart';
 import 'package:analysis_server/src/socket_server.dart';
 import 'package:analysis_server/starter.dart';
 import 'package:analyzer/file_system/physical_file_system.dart';
 import 'package:analyzer/instrumentation/file_instrumentation.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
 import 'package:analyzer/plugin/resolver_provider.dart';
 import 'package:analyzer/src/dart/sdk/sdk.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:args/args.dart';
 import 'package:linter/src/rules.dart' as linter;
 import 'package:plugin/manager.dart';
 import 'package:plugin/plugin.dart';
+import 'package:telemetry/crash_reporting.dart';
+import 'package:telemetry/telemetry.dart' as telemetry;
 
 /// Commandline argument parser. (Copied from analyzer/lib/options.dart)
 /// TODO(pquitslund): replaces with a simple [ArgParser] instance
 /// when the args package supports ignoring unrecognized
 /// options/flags (https://github.com/dart-lang/args/issues/9).
 class CommandLineParser {
   final List<String> _knownFlags;
   final bool _alwaysIgnoreUnrecognized;
   final ArgParser _parser;
 
@@ skipping 80 matching lines @@
     // Only filter args if the ignore flag is specified, or if
     // _alwaysIgnoreUnrecognized was set to true
     if (_alwaysIgnoreUnrecognized ||
         args.contains('--ignore-unrecognized-flags')) {
       // Filter all unrecognized flags and options.
       List<String> filtered = <String>[];
       for (int i = 0; i < args.length; ++i) {
         String arg = args[i];
         if (arg.startsWith('--') && arg.length > 2) {
           String option = arg.substring(2);
+          // remove any leading 'no-'
+          if (option.startsWith('no-')) {
+            option = option.substring(3);
+          }
           // strip the last '=value'
           int equalsOffset = option.lastIndexOf('=');
           if (equalsOffset != -1) {
             option = option.substring(0, equalsOffset);
           }
           // check the option
           if (!_knownFlags.contains(option)) {
             //"eat" params by advancing to the next flag/option
             i = _getNextFlagIndex(args, i);
           } else {
@@ skipping 50 matching lines @@
    * The name of the option used to set the file read mode.
    */
   static const String FILE_READ_MODE = "file-read-mode";
 
   /**
    * The name of the option used to print usage information.
    */
   static const String HELP_OPTION = "help";
 
   /**
+   * The name of the flag used to configure reporting analytics.
+   */
+  static const String ANALYTICS_FLAG = "analytics";
+
+  /**
    * The name of the option used to cause instrumentation to also be written to
    * a local file.
    */
   static const String INSTRUMENTATION_LOG_FILE = "instrumentation-log-file";
 
   /**
    * The name of the option used to specify if [print] should print to the
    * console instead of being intercepted.
    */
   static const String INTERNAL_PRINT_TO_CONSOLE = "internal-print-to-console";
@@ skipping 17 matching lines @@
 
   /**
    * The option for specifying the http diagnostic port.
    * If specified, users can review server status and performance information
    * by opening a web browser on http://localhost:<port>
    */
   static const String PORT_OPTION = "port";
 
   /**
    * The path to the SDK.
-   * TODO(paulberry): get rid of this once the 'analysis.updateSdks' request is
-   * operational.
    */
   static const String SDK_OPTION = "sdk";
 
   /**
    * The instrumentation server that is to be used by the analysis server.
    */
   InstrumentationServer instrumentationServer;
 
   /**
    * The file resolver provider used to override the way file URI's are
@@ skipping 30 matching lines @@
   /**
    * Use the given command-line [arguments] to start this server.
    *
    * At least temporarily returns AnalysisServer so that consumers of the
    * starter API can then use the server, this is done as a stopgap for the
    * angular plugin until the official plugin API is finished.
    */
   AnalysisServer start(List<String> arguments) {
     CommandLineParser parser = _createArgParser();
     ArgResults results = parser.parse(arguments, <String, String>{});
-    if (results[HELP_OPTION]) {
-      _printUsage(parser.parser);
+
+    AnalysisServerOptions analysisServerOptions = new AnalysisServerOptions();
+    analysisServerOptions.useAnalysisHighlight2 =
+        results[USE_ANALYSIS_HIGHLIGHT2];
+    analysisServerOptions.fileReadMode = results[FILE_READ_MODE];
+    analysisServerOptions.newAnalysisDriverLog =
+        results[NEW_ANALYSIS_DRIVER_LOG];
+    analysisServerOptions.clientId = results[CLIENT_ID];
+    analysisServerOptions.clientVersion = results[CLIENT_VERSION];
+    analysisServerOptions.enableVerboseFlutterCompletions =
+        results[VERBOSE_FLUTTER_COMPLETIONS];
+
+    // TODO(devoncarew): Replace with the real analytics tool ID.
+    telemetry.Analytics analytics =
+        telemetry.createAnalyticsInstance('UA-001', 'analysis-server');
+    analysisServerOptions.analytics = analytics;
+
+    if (analysisServerOptions.clientId != null) {
+      // Record the client name as the application installer ID.
+      analytics.setSessionValue('aiid', analysisServerOptions.clientId);
+    }
+    if (analysisServerOptions.clientVersion != null) {
+      analytics.setSessionValue('cd1', analysisServerOptions.clientVersion);
+    }
+
+    // TODO(devoncarew): Replace with the real crash product ID.
+    analysisServerOptions.crashReportSender =
+        new CrashReportSender('Dart-analysis-server', analytics);
+
+    if (results.wasParsed(ANALYTICS_FLAG)) {
+      analytics.enabled = results[ANALYTICS_FLAG];
+      print(telemetry.createAnalyticsStatusMessage(analytics.enabled));
       return null;
     }
 
+    if (results[HELP_OPTION]) {
+      _printUsage(parser.parser, analytics, fromHelp: true);
+      return null;
+    }
+
     int port;
     bool serve_http = false;
     if (results[PORT_OPTION] != null) {
       try {
         port = int.parse(results[PORT_OPTION]);
         serve_http = true;
       } on FormatException {
         print('Invalid port number: ${results[PORT_OPTION]}');
         print('');
-        _printUsage(parser.parser);
+        _printUsage(parser.parser, analytics);
         exitCode = 1;
         return null;
       }
     }
 
-    AnalysisServerOptions analysisServerOptions = new AnalysisServerOptions();
-    analysisServerOptions.useAnalysisHighlight2 =
-        results[USE_ANALYSIS_HIGHLIGHT2];
-    analysisServerOptions.fileReadMode = results[FILE_READ_MODE];
-    analysisServerOptions.newAnalysisDriverLog =
-        results[NEW_ANALYSIS_DRIVER_LOG];
-
-    analysisServerOptions.clientId = results[CLIENT_ID];
-    analysisServerOptions.clientVersion = results[CLIENT_VERSION];
-
-    analysisServerOptions.enableVerboseFlutterCompletions =
-        results[VERBOSE_FLUTTER_COMPLETIONS];
-
     //
     // Process all of the plugins so that extensions are registered.
     //
     ServerPlugin serverPlugin = new ServerPlugin();
     List<Plugin> plugins = <Plugin>[];
     plugins.addAll(AnalysisEngine.instance.requiredPlugins);
     plugins.add(serverPlugin);
     plugins.add(dartCompletionPlugin);
     plugins.addAll(_userDefinedPlugins);
     ExtensionManager manager = new ExtensionManager();
@@ skipping 24 matching lines @@
           new FileInstrumentationServer(logFilePath);
       instrumentationServer = instrumentationServer != null
           ? new MulticastInstrumentationServer(
               [instrumentationServer, fileBasedServer])
           : fileBasedServer;
     }
     InstrumentationService instrumentationService =
         new InstrumentationService(instrumentationServer);
     instrumentationService.logVersion(
         _readUuid(instrumentationService),
-        results[CLIENT_ID],
-        results[CLIENT_VERSION],
+        analysisServerOptions.clientId,
+        analysisServerOptions.clientVersion,
         AnalysisServer.VERSION,
         defaultSdk.sdkVersion);
     AnalysisEngine.instance.instrumentationService = instrumentationService;
 
     _DiagnosticServerImpl diagnosticServer = new _DiagnosticServerImpl();
 
+    // Ping analytics with our initial call.
+    analytics.sendScreenView('home');
+
     //
     // Create the sockets and start listening for requests.
     //
     socketServer = new SocketServer(
         analysisServerOptions,
         new DartSdkManager(defaultSdkPath, true),
         defaultSdk,
         instrumentationService,
         diagnosticServer,
         serverPlugin,
@@ skipping 63 matching lines @@
     parser.addFlag(ENABLE_INSTRUMENTATION_OPTION,
         help: "enable sending instrumentation information to a server",
         defaultsTo: false,
         negatable: false);
     parser.addFlag(HELP_OPTION,
         help: "print this help message without starting a server",
         abbr: 'h',
         defaultsTo: false,
         negatable: false);
     parser.addOption(INSTRUMENTATION_LOG_FILE,
-        help:
-            "the path of the file to which instrumentation data will be written");
+        help: "write instrumentation data to the given file");
     parser.addFlag(INTERNAL_PRINT_TO_CONSOLE,
         help: "enable sending `print` output to the console",
         defaultsTo: false,
         negatable: false);
     parser.addOption(NEW_ANALYSIS_DRIVER_LOG,
         help: "set a destination for the new analysis driver's log");
     parser.addFlag(VERBOSE_FLUTTER_COMPLETIONS,
         help: "enable verbose code completion for Flutter (experimental)");
+    parser.addFlag(ANALYTICS_FLAG,
+        help: 'enable or disable sending analytics information to Google');
     parser.addOption(PORT_OPTION,
         help: "the http diagnostic port on which the server provides"
             " status and performance information");
     parser.addOption(SDK_OPTION, help: "[path] the path to the sdk");
     parser.addFlag(USE_ANALYSIS_HIGHLIGHT2,
         help: "enable version 2 of semantic highlight",
         defaultsTo: false,
         negatable: false);
     parser.addOption(FILE_READ_MODE,
         help: "an option for reading files (some clients normalize eol "
@@ skipping 15 matching lines @@
         PhysicalResourceProvider.INSTANCE;
     FolderBasedDartSdk sdk = new FolderBasedDartSdk(
         resourceProvider, resourceProvider.getFolder(defaultSdkPath));
     sdk.useSummary = useSummaries;
     return sdk;
   }
 
   /**
    * Print information about how to use the server.
    */
-  void _printUsage(ArgParser parser) {
+  void _printUsage(ArgParser parser, telemetry.Analytics analytics,
+      {bool fromHelp: false}) {
     print('Usage: $BINARY_NAME [flags]');
     print('');
     print('Supported flags are:');
     print(parser.usage);
+
+    // Print analytics status and information.
+    if (fromHelp) {
+      print('');
+      print(telemetry.analyticsNotice);
+    }
+    print('');
+    print(telemetry.createAnalyticsStatusMessage(analytics.enabled,
+        command: ANALYTICS_FLAG));
   }
 
   /**
    * Read the UUID from disk, generating and storing a new one if necessary.
    */
   String _readUuid(InstrumentationService service) {
     File uuidFile = new File(PhysicalResourceProvider.INSTANCE
         .getStateLocation('.instrumentation')
         .getChild('uuid.txt')
         .path);
@@ skipping 46 matching lines @@
 
   _DiagnosticServerImpl();
 
   @override
   Future<int> getServerPort() => httpServer.serveHttp();
 
   Future startOnPort(int port) {
     return httpServer.serveHttp(port);
   }
 }