send priority instrumentation message on startup with version info

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.
 
 library driver;
 
 import 'dart:async';
 import 'dart:io';
+import 'dart:math';
 
 import 'package:analysis_server/plugin/plugin.dart';
 import 'package:analysis_server/src/analysis_server.dart';
+import 'package:analysis_server/src/constants.dart';
 import 'package:analysis_server/src/plugin/plugin_impl.dart';
 import 'package:analysis_server/src/plugin/server_plugin.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/instrumentation.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/incremental_logger.dart';
 import 'package:analyzer/src/generated/java_io.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/sdk_io.dart';
 import 'package:args/args.dart';
 
-
 /**
  * Initializes incremental logger.
  *
  * Supports following formats of [spec]:
  *
  *     "console" - log to the console;
  *     "file:/some/file/name" - log to the file, overwritten on start.
  */
 void _initIncrementalLogger(String spec) {
   logger = NULL_LOGGER;
@@ skipping 23 matching lines @@
    * The name of the application that is used to start a server.
    */
   static const BINARY_NAME = "server";
 
   /**
    * The name of the option used to set the identifier for the client.
    */
   static const String CLIENT_ID = "client-id";
 
   /**
+   * The name of the option used to set the version for the client.
+   */
+  static const String CLIENT_VERSION = "client-version";
+
+  /**
    * The name of the option used to enable incremental resolution of API
    * changes.
    */
   static const String ENABLE_INCREMENTAL_RESOLUTION_API =
       "enable-incremental-resolution-api";
 
   /**
    * The name of the option used to describe the incremental resolution logger.
    */
   static const String INCREMENTAL_RESOLUTION_LOG = "incremental-resolution-log";
@@ skipping 121 matching lines @@
     if (results[SDK_OPTION] != null) {
       defaultSdk = new DirectoryBasedDartSdk(new JavaFile(results[SDK_OPTION]));
     } else {
       // No path to the SDK provided; use DirectoryBasedDartSdk.defaultSdk,
       // which will make a guess.
       defaultSdk = DirectoryBasedDartSdk.defaultSdk;
     }
 
     InstrumentationService service =
         new InstrumentationService(instrumentationServer);
-//    service.logVersion(results[CLIENT_ID], defaultSdk.sdkVersion);
+    service.logVersion(
+        _readUuid(service),
+        results[CLIENT_ID],
+        results[CLIENT_VERSION],
+        AnalysisServer.VERSION,
+        defaultSdk.sdkVersion);
     AnalysisEngine.instance.instrumentationService = service;
     //
     // Process all of the plugins so that extensions are registered.
     //
     ServerPlugin serverPlugin = new ServerPlugin();
     List<Plugin> plugins = <Plugin>[];
     plugins.add(serverPlugin);
     plugins.addAll(_userDefinedPlugins);
     ExtensionManager manager = new ExtensionManager();
     manager.processPlugins(plugins);
@@ skipping 49 matching lines @@
   }
 
   /**
    * Create and return the parser used to parse the command-line arguments.
    */
   ArgParser _createArgParser() {
     ArgParser parser = new ArgParser();
     parser.addOption(
         CLIENT_ID,
         help: "an identifier used to identify the client");
+    parser.addOption(CLIENT_VERSION, help: "the version of the client");
     parser.addFlag(
         ENABLE_INCREMENTAL_RESOLUTION_API,
         help: "enable using incremental resolution for API changes",
         defaultsTo: false,
         negatable: false);
     parser.addFlag(
         ENABLE_INSTRUMENTATION_OPTION,
         help: "enable sending instrumentation information to a server",
         defaultsTo: false,
         negatable: false);
@@ skipping 14 matching lines @@
         INTERNAL_PRINT_TO_CONSOLE,
         help: "enable sending `print` output to the console",
         defaultsTo: false,
         negatable: false);
     parser.addOption(
         PORT_OPTION,
         help: "[port] the port on which the server will listen");
     parser.addOption(SDK_OPTION, help: "[path] the path to the sdk");
     parser.addFlag(
         NO_ERROR_NOTIFICATION,
-        help:
-            "disable sending all analysis error notifications to the server",
+        help: "disable sending all analysis error notifications to the server",
         defaultsTo: false,
         negatable: false);
 
     return parser;
   }
 
   /**
    * Print information about how to use the server.
    */
   void _printUsage(ArgParser parser) {
     print('Usage: $BINARY_NAME [flags]');
     print('');
     print('Supported flags are:');
     print(parser.usage);
   }
+
+  /**
+   * 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);
+    try {
+      if (uuidFile.existsSync()) {
+        String uuid = uuidFile.readAsStringSync();
+        if (uuid != null && uuid.length > 5) {
+          return uuid;
+        }
+      }
+    } catch (exception, stackTrace) {
+      service.logPriorityException(exception, stackTrace);
+    }
+    int millisecondsSinceEpoch = new DateTime.now().millisecondsSinceEpoch;
+    int random = new Random().nextInt(0x3fffffff);
+    String uuid = '$millisecondsSinceEpoch$random';
+    try {
+      uuidFile.parent.createSync(recursive: true);
+      uuidFile.writeAsStringSync(uuid);
+    } catch (exception, stackTrace) {
+      service.logPriorityException(exception, stackTrace);
+      // Slightly alter the uuid to indicate it was not persisted
+      uuid = 'temp-$uuid';
+    }
+    return uuid;
+  }
 }