Send any logError() information to the IDE.

pkg/analysis_server/lib/src/analysis_server.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 analysis.server;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:core' hide Resource;
 import 'dart:math' show max;
 
-import 'package:analysis_server/plugin/analysis/analyzed_files.dart';
 import 'package:analysis_server/plugin/analysis/resolver_provider.dart';
 import 'package:analysis_server/plugin/protocol/protocol.dart' hide Element;
 import 'package:analysis_server/src/analysis_logger.dart';
 import 'package:analysis_server/src/channel/channel.dart';
 import 'package:analysis_server/src/context_manager.dart';
 import 'package:analysis_server/src/operation/operation.dart';
 import 'package:analysis_server/src/operation/operation_analysis.dart';
 import 'package:analysis_server/src/operation/operation_queue.dart';
 import 'package:analysis_server/src/plugin/server_plugin.dart';
 import 'package:analysis_server/src/services/correction/namespace.dart';
@@ skipping 288 matching lines @@
     ServerContextManagerCallbacks contextManagerCallbacks =
         new ServerContextManagerCallbacks(this, resourceProvider);
     contextManager.callbacks = contextManagerCallbacks;
     defaultContextOptions.incremental = true;
     defaultContextOptions.incrementalApi =
         options.enableIncrementalResolutionApi;
     defaultContextOptions.incrementalValidation =
         options.enableIncrementalResolutionValidation;
     defaultContextOptions.generateImplicitErrors = false;
     _noErrorNotification = options.noErrorNotification;
-    AnalysisEngine.instance.logger = new AnalysisLogger();
+    AnalysisEngine.instance.logger = new AnalysisLogger(
+        onError: (String message, CaughtException exception) {
+      sendServerErrorNotification(message, exception, exception?.stackTrace,
+          fatal: false);
+    });
     _onAnalysisStartedController = new StreamController.broadcast();
     _onFileAnalyzedController = new StreamController.broadcast();
     _onPriorityChangeController =
         new StreamController<PriorityChangeEvent>.broadcast();
     running = true;
     onAnalysisStarted.first.then((_) {
       onAnalysisComplete.then((_) {
         performanceAfterStartup = new ServerPerformance();
         _performance = performanceAfterStartup;
       });
@@ skipping 374 matching lines @@
               error.stackTrace = stackTrace.toString();
             }
             Response response = new Response(request.id, error: error);
             channel.sendResponse(response);
             return;
           }
         }
         channel.sendResponse(new Response.unknownRequest(request));
       });
     }, onError: (exception, stackTrace) {
-      sendServerErrorNotification(exception, stackTrace, fatal: true);
+      sendServerErrorNotification(null, exception, stackTrace, fatal: true);

[Brian Wilkerson, 2015/11/12 14:52:51]

I think we should always provide a message that identifies where the exception
occurred and any additional information we might want in order to debug it. For
example, in this place we could include the request that caused the exception:

   "Failed to handle request: ${request.toJson()}"

[scheglov, 2015/11/12 16:15:56]

Done.

     });
   }
 
   /**
    * Returns `true` if there is a subscription for the given [service] and
    * [file].
    */
   bool hasAnalysisSubscription(AnalysisService service, String file) {
     Set<String> files = analysisServices[service];
     return files != null && files.contains(file);
@@ skipping 60 matching lines @@
       // loop is in progress.  No problem; we just need to exit the operation
       // loop and wait for the next operation to be added.
       ServerPerformanceStatistics.idle.makeCurrent();
       return;
     }
     sendStatusNotification(operation);
     // perform the operation
     try {
       operation.perform(this);
     } catch (exception, stackTrace) {
-      AnalysisEngine.instance.logger.logError("${exception}\n${stackTrace}");
+      sendServerErrorNotification(null, exception, stackTrace, fatal: true);
       if (rethrowExceptions) {
         throw new AnalysisException('Unexpected exception during analysis',
             new CaughtException(exception, stackTrace));
       }
-      sendServerErrorNotification(exception, stackTrace, fatal: true);
       shutdown();
     } finally {
       if (_test_onOperationPerformedCompleter != null) {
         _test_onOperationPerformedCompleter.complete(operation);
         _test_onOperationPerformedCompleter = null;
       }
       if (!operationQueue.isEmpty) {
         ServerPerformanceStatistics.intertask.makeCurrent();
         _schedulePerformOperation();
       } else {
@@ skipping 69 matching lines @@
   /**
    * Send the given [response] to the client.
    */
   void sendResponse(Response response) {
     channel.sendResponse(response);
   }
 
   /**
    * Sends a `server.error` notification.
    */
-  void sendServerErrorNotification(exception, stackTrace, {bool fatal: false}) {
+  void sendServerErrorNotification(String msg, exception, stackTrace,
+      {bool fatal: false}) {
     // prepare exception.toString()
     String exceptionString;
     if (exception != null) {
       exceptionString = exception.toString();
     } else {
       exceptionString = 'null exception';
     }
+    // prepare message
+    String message = msg != null ? '$msg\n$exceptionString' : exceptionString;
     // prepare stackTrace.toString()
     String stackTraceString;
     if (stackTrace != null) {
       stackTraceString = stackTrace.toString();
     } else {
       try {
         throw 'ignored';
       } catch (ignored, stackTrace) {
         stackTraceString = stackTrace.toString();
       }
       if (stackTraceString == null) {
         // This code should be unreachable.
         stackTraceString = 'null stackTrace';
       }
     }
     // send the notification
     channel.sendNotification(
-        new ServerErrorParams(fatal, exceptionString, stackTraceString)
+        new ServerErrorParams(fatal, message, stackTraceString)
             .toNotification());
   }
 
   /**
    * Send status notification to the client. The `operation` is the operation
    * being performed or `null` if analysis is complete.
    */
   void sendStatusNotification(ServerOperation operation) {
     // Only send status when subscribed.
     if (!serverServices.contains(ServerService.STATUS)) {
@@ skipping 705 matching lines @@
   /**
    * The [PerformanceTag] for time spent in server request handlers.
    */
   static PerformanceTag serverRequests = new PerformanceTag('serverRequests');
 
   /**
    * The [PerformanceTag] for time spent in split store microtasks.
    */
   static PerformanceTag splitStore = new PerformanceTag('splitStore');
 }