blob: 4628c6f7fa5fca2e19cbc92a03473229959b7512 [file] [log] [blame]
// Copyright (c) 2017, 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:convert';
import 'dart:developer' as developer;
import 'dart:io';
import 'package:analysis_server/protocol/protocol_generated.dart';
import 'package:analysis_server/src/analysis_server.dart';
import 'package:analysis_server/src/domain_completion.dart';
import 'package:analysis_server/src/domain_diagnostic.dart';
import 'package:analysis_server/src/plugin/plugin_manager.dart';
import 'package:analysis_server/src/server/http_server.dart';
import 'package:analysis_server/src/services/completion/completion_performance.dart';
import 'package:analysis_server/src/socket_server.dart';
import 'package:analysis_server/src/status/ast_writer.dart';
import 'package:analysis_server/src/status/element_writer.dart';
import 'package:analysis_server/src/status/pages.dart';
import 'package:analysis_server/src/utilities/profiling.dart';
import 'package:analyzer/file_system/file_system.dart';
import 'package:analyzer/instrumentation/instrumentation.dart';
import 'package:analyzer/src/context/context_root.dart';
import 'package:analyzer/src/context/source.dart';
import 'package:analyzer/src/dart/analysis/driver.dart';
import 'package:analyzer/src/dart/analysis/file_state.dart';
import 'package:analyzer/src/dart/sdk/sdk.dart';
import 'package:analyzer/src/generated/engine.dart' hide AnalysisResult;
import 'package:analyzer/src/generated/sdk.dart';
import 'package:analyzer/src/generated/source.dart';
import 'package:analyzer/src/generated/utilities_general.dart';
import 'package:analyzer/src/lint/linter.dart';
import 'package:analyzer/src/lint/registry.dart';
import 'package:analyzer/src/services/lint.dart';
import 'package:analyzer/src/source/package_map_resolver.dart';
import 'package:analyzer/src/source/sdk_ext.dart';
import 'package:path/path.dart' as pathPackage;
final String kCustomCss = '''
.lead, .page-title+.markdown-body>p:first-child {
margin-bottom: 30px;
font-size: 20px;
font-weight: 300;
color: #555;
}
.container {
width: 1160px;
}
.masthead {
padding-top: 1rem;
padding-bottom: 1rem;
margin-bottom: 1.5rem;
text-align: center;
background-color: #4078c0;
}
.masthead .masthead-logo {
display: inline-block;
font-size: 1.5rem;
color: #fff;
float: left;
}
.masthead .mega-octicon {
font-size: 1.5rem;
}
.masthead-nav {
float: right;
margin-top: .5rem;
}
.masthead-nav a:not(:last-child) {
margin-right: 1.25rem;
}
.masthead a {
color: rgba(255,255,255,0.5);
font-size: 1rem;
}
.masthead a:hover {
color: #fff;
text-decoration: none;
}
.masthead-nav .active {
color: #fff;
font-weight: 500;
}
.counter {
display: inline-block;
padding: 2px 5px;
font-size: 11px;
font-weight: bold;
line-height: 1;
color: #666;
background-color: #eee;
border-radius: 20px;
}
.menu-item .counter {
float: right;
margin-left: 5px;
}
td.right {
text-align: right;
}
table td {
max-width: 600px;
vertical-align: text-top;
}
td.pre {
white-space: pre;
}
.nowrap {
white-space: nowrap;
}
.scroll-table {
max-height: 190px;
overflow-x: auto;
}
.footer {
padding-top: 3rem;
padding-bottom: 3rem;
margin-top: 3rem;
line-height: 1.75;
color: #7a7a7a;
border-top: 1px solid #eee;
}
.footer strong {
color: #333;
}
''';
final bool _showLints = false;
String get _sdkVersion {
String version = Platform.version;
if (version.contains(' ')) {
version = version.substring(0, version.indexOf(' '));
}
return version;
}
String writeOption(String name, dynamic value) {
return '$name: <code>$value</code><br> ';
}
class AstPage extends DiagnosticPageWithNav {
String _description;
AstPage(DiagnosticsSite site)
: super(site, 'ast', 'AST', description: 'The AST for a file.');
@override
String get description => _description ?? super.description;
@override
bool get showInNav => false;
@override
Future<void> generateContent(Map<String, String> params) async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
String path = params['file'];
if (path == null) {
p('No file path provided.');
return;
}
AnalysisDriver driver = server.getAnalysisDriver(path);
if (driver == null) {
p('The file <code>${escape(path)}</code> is not being analyzed.',
raw: true);
return;
}
AnalysisResult result = await driver.getResult(path);
if (result == null) {
p(
'An AST could not be produced for the file '
'<code>${escape(path)}</code>.',
raw: true);
return;
}
AstWriter writer = new AstWriter(buf);
result.unit.accept(writer);
}
@override
Future<void> generatePage(Map<String, String> params) async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
try {
_description = params['file'];
await super.generatePage(params);
} finally {
_description = null;
}
}
}
class CommunicationsPage extends DiagnosticPageWithNav {
CommunicationsPage(DiagnosticsSite site)
: super(site, 'communications', 'Communications',
description:
'Latency statistics for analysis server communications.');
@override
Future generateContent(Map<String, String> params) async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
void writeRow(List<String> data, {List<String> classes}) {
buf.write("<tr>");
for (int i = 0; i < data.length; i++) {
String c = classes == null ? null : classes[i];
if (c != null) {
buf.write('<td class="$c">${escape(data[i])}</td>');
} else {
buf.write('<td>${escape(data[i])}</td>');
}
}
buf.writeln("</tr>");
}
buf.writeln('<div class="columns">');
ServerPerformance perf = server.performanceAfterStartup;
if (perf != null) {
buf.writeln('<div class="column one-half">');
h3('Current');
int requestCount = perf.requestCount;
int averageLatency =
requestCount > 0 ? (perf.requestLatency ~/ requestCount) : 0;
int maximumLatency = perf.maxLatency;
double slowRequestPercent =
requestCount > 0 ? (perf.slowRequestCount / requestCount) : 0.0;
buf.write('<table>');
writeRow([printInteger(requestCount), 'requests'],
classes: ["right", null]);
writeRow([printMilliseconds(averageLatency), 'average latency'],
classes: ["right", null]);
writeRow([printMilliseconds(maximumLatency), 'maximum latency'],
classes: ["right", null]);
writeRow([printPercentage(slowRequestPercent), '> 150 ms latency'],
classes: ["right", null]);
buf.write('</table>');
String time = server.uptime.toString();
if (time.contains('.')) {
time = time.substring(0, time.indexOf('.'));
}
buf.writeln(writeOption('Uptime', time));
buf.write('</div>');
}
buf.writeln('<div class="column one-half">');
h3('Startup');
perf = server.performanceDuringStartup;
int requestCount = perf.requestCount;
int averageLatency =
requestCount > 0 ? (perf.requestLatency ~/ requestCount) : 0;
int maximumLatency = perf.maxLatency;
double slowRequestPercent =
requestCount > 0 ? (perf.slowRequestCount / requestCount) : 0.0;
buf.write('<table>');
writeRow([printInteger(requestCount), 'requests'],
classes: ["right", null]);
writeRow([printMilliseconds(averageLatency), 'average latency'],
classes: ["right", null]);
writeRow([printMilliseconds(maximumLatency), 'maximum latency'],
classes: ["right", null]);
writeRow([printPercentage(slowRequestPercent), '> 150 ms latency'],
classes: ["right", null]);
buf.write('</table>');
if (server.performanceAfterStartup != null) {
int startupTime =
server.performanceAfterStartup.startTime - perf.startTime;
buf.writeln(
writeOption('Initial analysis time', printMilliseconds(startupTime)));
}
buf.write('</div>');
buf.write('</div>');
}
}
class CompletionPage extends DiagnosticPageWithNav {
CompletionPage(DiagnosticsSite site)
: super(site, 'completion', 'Code Completion',
description: 'Latency statistics for code completion.');
@override
Future generateContent(Map<String, String> params) async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
CompletionDomainHandler completionDomain = server.handlers
.firstWhere((handler) => handler is CompletionDomainHandler);
List<CompletionPerformance> completions =
completionDomain.performanceList.items.toList();
if (completions.isEmpty) {
blankslate('No completions recorded.');
return;
}
int fastCount =
completions.where((c) => c.elapsedInMilliseconds <= 100).length;
p('${completions.length} results; ${printPercentage(fastCount / completions.length)} within 100ms.');
// draw a chart
buf.writeln(
'<div id="chart-div" style="width: 700px; height: 300px;"></div>');
StringBuffer rowData = new StringBuffer();
for (int i = completions.length - 1; i >= 0; i--) {
// [' ', 101.5]
if (rowData.isNotEmpty) {
rowData.write(',');
}
rowData.write("[' ', ${completions[i].elapsedInMilliseconds}]");
}
buf.writeln('''
<script type="text/javascript">
google.charts.load('current', {'packages':['bar']});
google.charts.setOnLoadCallback(drawChart);
function drawChart() {
var data = google.visualization.arrayToDataTable([
['Completions', 'Time'],
$rowData
]);
var options = { bars: 'vertical', vAxis: {format: 'decimal'}, height: 300 };
var chart = new google.charts.Bar(document.getElementById('chart-div'));
chart.draw(data, google.charts.Bar.convertOptions(options));
}
</script>
''');
// emit the data as a table
buf.writeln('<table>');
buf.writeln(
'<tr><th>Time</th><th>Results</th><th>Source</th><th>Snippet</th></tr>');
var pathContext = completionDomain.server.resourceProvider.pathContext;
for (CompletionPerformance completion in completions) {
String shortName = pathContext.basename(completion.path);
buf.writeln('<tr>'
'<td class="pre right">${printMilliseconds(completion.elapsedInMilliseconds)}</td>'
'<td class="right">${completion.suggestionCount}</td>'
'<td>${escape(shortName)}</td>'
'<td><code>${escape(completion.snippet)}</code></td>'
'</tr>');
}
buf.writeln('</table>');
}
}
class ContextsPage extends DiagnosticPageWithNav {
ContextsPage(DiagnosticsSite site)
: super(site, 'contexts', 'Contexts',
description:
'An analysis context defines the options and the set of sources being analyzed.');
String get navDetail => printInteger(server.driverMap.length);
String describe(AnalysisOptionsImpl options) {
StringBuffer b = new StringBuffer();
b.write(writeOption('Strong mode', options.strongMode));
b.write(writeOption('Implicit dynamic', options.implicitDynamic));
b.write(writeOption('Implicit casts', options.implicitCasts));
b.write(writeOption('Declaration casts', options.declarationCasts));
b.write(
writeOption('Analyze function bodies', options.analyzeFunctionBodies));
b.write(writeOption('Enable super mixins', options.enableSuperMixins));
b.write(writeOption('Generate dart2js hints', options.dart2jsHint));
b.write(writeOption(
'Generate errors in implicit files', options.generateImplicitErrors));
b.write(
writeOption('Generate errors in SDK files', options.generateSdkErrors));
b.write(writeOption('Generate hints', options.hint));
b.write(writeOption('Preserve comments', options.preserveComments));
b.write(writeOption('Strong mode hints', options.strongModeHints));
return b.toString();
}
@override
Future generateContent(Map<String, String> params) async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
Map<Folder, AnalysisDriver> driverMap = server.driverMap;
if (driverMap.isEmpty) {
blankslate('No contexts.');
return;
}
String contextPath = params['context'];
List<Folder> folders = driverMap.keys.toList();
folders
.sort((first, second) => first.shortName.compareTo(second.shortName));
Folder folder =
folders.firstWhere((f) => f.path == contextPath, orElse: () => null);
if (folder == null) {
folder = folders.first;
contextPath = folder.path;
}
AnalysisDriver driver = driverMap[folder];
buf.writeln('<div class="tabnav">');
buf.writeln('<nav class="tabnav-tabs">');
for (Folder f in folders) {
if (f == folder) {
buf.writeln(
'<a class="tabnav-tab selected">${escape(f.shortName)}</a>');
} else {
String p = '$path?context=${Uri.encodeQueryComponent(f.path)}';
buf.writeln(
'<a href="$p" class="tabnav-tab">${escape(f.shortName)}</a>');
}
}
buf.writeln('</nav>');
buf.writeln('</div>');
buf.writeln(writeOption('Context location', escape(contextPath)));
buf.writeln(writeOption('Analysis options path',
escape(driver.contextRoot.optionsFilePath ?? 'none')));
buf.writeln('<div class="columns">');
buf.writeln('<div class="column one-half">');
h3('Analysis options');
p(describe(driver.analysisOptions), raw: true);
buf.writeln(
writeOption('Has .packages file', folder.getChild('.packages').exists));
buf.writeln(writeOption(
'Has pubspec.yaml file', folder.getChild('pubspec.yaml').exists));
buf.writeln('</div>');
buf.writeln('<div class="column one-half">');
DartSdk sdk = driver?.sourceFactory?.dartSdk;
AnalysisOptionsImpl sdkOptions = sdk?.context?.analysisOptions;
if (sdkOptions != null) {
h3('SDK analysis options');
p(describe(sdkOptions), raw: true);
if (sdk is FolderBasedDartSdk) {
p(writeOption('Use summaries', sdk.useSummary), raw: true);
}
}
buf.writeln('</div>');
buf.writeln('</div>');
h3('Lints');
p(driver.analysisOptions.lintRules.map((l) => l.name).join(', '));
h3('Error processors');
p(driver.analysisOptions.errorProcessors
.map((e) => e.description)
.join(', '));
h3('Plugins');
p(driver.analysisOptions.enabledPluginNames.join(', '));
List<String> priorityFiles = driver.priorityFiles;
List<String> addedFiles = driver.addedFiles.toList();
List<String> implicitFiles =
driver.knownFiles.difference(driver.addedFiles).toList();
addedFiles.sort();
implicitFiles.sort();
String lenCounter(List list) {
return '<span class="counter" style="float: right;">${list.length}</span>';
}
h3('Context files');
void writeFile(String file) {
String astPath = '/ast?file=${Uri.encodeQueryComponent(file)}';
String elementPath = '/element?file=${Uri.encodeQueryComponent(file)}';
buf.write(file);
buf.writeln(' <a href="$astPath">ast</a>');
buf.write(' ');
buf.writeln('<a href="$elementPath">element</a>');
}
h4('Priority files ${lenCounter(priorityFiles)}', raw: true);
ul(priorityFiles, writeFile, classes: 'scroll-table');
h4('Added files ${lenCounter(addedFiles)}', raw: true);
ul(addedFiles, writeFile, classes: 'scroll-table');
h4('Implicit files ${lenCounter(implicitFiles)}', raw: true);
ul(implicitFiles, writeFile, classes: 'scroll-table');
SourceFactory sourceFactory = driver.sourceFactory;
if (sourceFactory is SourceFactoryImpl) {
h3('Resolvers');
for (UriResolver resolver in sourceFactory.resolvers) {
h4(resolver.runtimeType.toString());
buf.write('<p class="scroll-table">');
if (resolver is DartUriResolver) {
DartSdk sdk = resolver.dartSdk;
buf.write(' (sdk = ');
buf.write(sdk.runtimeType);
if (sdk is FolderBasedDartSdk) {
buf.write(' (path = ');
buf.write(sdk.directory.path);
buf.write(')');
} else if (sdk is EmbedderSdk) {
buf.write(' (map = ');
writeMap(sdk.urlMappings);
buf.write(')');
}
buf.write(')');
} else if (resolver is SdkExtUriResolver) {
buf.write(' (map = ');
writeMap(resolver.urlMappings);
buf.write(')');
} else if (resolver is PackageMapUriResolver) {
writeMap(resolver.packageMap);
}
buf.write('</p>');
}
}
}
void writeList<E>(List<E> list) {
buf.writeln('[${list.join(', ')}]');
}
void writeMap<V>(Map<String, V> map) {
List<String> keys = map.keys.toList();
keys.sort();
int length = keys.length;
buf.write('{');
for (int i = 0; i < length; i++) {
buf.write('<br>');
String key = keys[i];
V value = map[key];
buf.write(key);
buf.write(' = ');
if (value is List) {
writeList(value);
} else {
buf.write(value);
}
buf.write(',');
}
buf.write('<br>}');
}
}
/// A page with a proscriptive notion of layout.
abstract class DiagnosticPage extends Page {
final Site site;
DiagnosticPage(this.site, String id, String title, {String description})
: super(id, title, description: description);
bool get isNavPage => false;
AnalysisServer get server =>
(site as DiagnosticsSite).socketServer.analysisServer;
Future<void> generateContainer(Map<String, String> params) async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
buf.writeln('<div class="columns docs-layout">');
buf.writeln('<div class="three-fourths column markdown-body">');
h1(title, classes: 'page-title');
await asyncDiv(() async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
p(description);
await generateContent(params);
}, classes: 'markdown-body');
buf.writeln('</div>');
buf.writeln('</div>');
}
Future<void> generateContent(Map<String, String> params);
void generateFooter() {
buf.writeln('''
<footer class="footer">
Dart ${site.title} <span style="float:right">SDK $_sdkVersion</span>
</footer>
''');
}
void generateHeader() {
buf.writeln('''
<header class="masthead">
<div class="container">
<span class="masthead-logo">
<span class="mega-octicon octicon-dashboard"></span>
${site.title} Diagnostics
</span>
<nav class="masthead-nav">
<a href="/status" ${isNavPage ? ' class="active"' : ''}>Diagnostics</a>
<a href="/feedback" ${isCurrentPage('/feedback') ? ' class="active"' : ''}>Feedback</a>
<a href="https://www.dartlang.org/tools/analyzer" target="_blank">Docs</a>
<a href="https://htmlpreview.github.io/?https://github.com/dart-lang/sdk/blob/master/pkg/analysis_server/doc/api.html" target="_blank">Spec</a>
</nav>
</div>
</header>
''');
}
Future<void> generatePage(Map<String, String> params) async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
buf.writeln('<!DOCTYPE html><html lang="en">');
buf.write('<head>');
buf.write('<meta charset="utf-8">');
buf.write('<meta name="viewport" content="width=device-width, '
'initial-scale=1.0">');
buf.writeln('<title>${site.title}</title>');
buf.writeln('<link rel="stylesheet" '
'href="https://cdnjs.cloudflare.com/ajax/libs/Primer/6.0.0/build.css">');
buf.writeln('<link rel="stylesheet" '
'href="https://cdnjs.cloudflare.com/ajax/libs/octicons/4.4.0/font/octicons.css">');
buf.writeln('<script type="text/javascript" '
'src="https://www.gstatic.com/charts/loader.js"></script>');
buf.writeln('<style>${site.customCss}</style>');
buf.writeln('</head>');
buf.writeln('<body>');
generateHeader();
buf.writeln('<div class="container">');
await generateContainer(params);
generateFooter();
buf.writeln('</div>'); // div.container
buf.writeln('</body>');
buf.writeln('</html>');
}
}
abstract class DiagnosticPageWithNav extends DiagnosticPage {
DiagnosticPageWithNav(Site site, String id, String title,
{String description})
: super(site, id, title, description: description);
bool get isNavPage => true;
String get navDetail => null;
bool get showInNav => true;
Future<void> generateContainer(Map<String, String> params) async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
buf.writeln('<div class="columns docs-layout">');
bool shouldShowInNav(Page page) {
return page is DiagnosticPageWithNav && page.showInNav;
}
buf.writeln('<div class="one-fifth column">');
buf.writeln('<nav class="menu docs-menu">');
for (Page page in site.pages.where(shouldShowInNav)) {
buf.write('<a class="menu-item ${page == this ? ' selected' : ''}" '
'href="${page.path}">${escape(page.title)}');
String detail = (page as DiagnosticPageWithNav).navDetail;
if (detail != null) {
buf.write('<span class="counter">$detail</span>');
}
buf.writeln('</a>');
}
buf.writeln('</nav>');
buf.writeln('</div>');
buf.writeln('<div class="four-fifths column markdown-body">');
h1(title, classes: 'page-title');
await asyncDiv(() async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
p(description);
await generateContent(params);
}, classes: 'markdown-body');
buf.writeln('</div>');
buf.writeln('</div>');
}
}
class DiagnosticsSite extends Site implements AbstractGetHandler {
/// An object that can handle either a WebSocket connection or a connection
/// to the client over stdio.
SocketServer socketServer;
/// The last few lines printed.
List<String> lastPrintedLines = <String>[];
DiagnosticsSite(this.socketServer, this.lastPrintedLines)
: super('Analysis Server') {
pages.add(new CompletionPage(this));
pages.add(new CommunicationsPage(this));
pages.add(new ContextsPage(this));
pages.add(new EnvironmentVariablesPage(this));
pages.add(new ExceptionsPage(this));
pages.add(new InstrumentationPage(this));
pages.add(new OverlaysPage(this));
pages.add(new PluginsPage(this));
pages.add(new ProfilePage(this));
pages.add(new SubscriptionsPage(this));
ProcessProfiler profiler = ProcessProfiler.getProfilerForPlatform();
if (profiler != null) {
pages.add(new MemoryAndCpuPage(this, profiler));
}
pages.sort(((Page a, Page b) =>
a.title.toLowerCase().compareTo(b.title.toLowerCase())));
// Add the status page at the beginning.
pages.insert(0, new StatusPage(this));
// Add non-nav pages.
pages.add(new FeedbackPage(this));
pages.add(new AstPage(this));
pages.add(new ElementModelPage(this));
}
String get customCss => kCustomCss;
Page createExceptionPage(String message, StackTrace trace) =>
new ExceptionPage(this, message, trace);
Page createUnknownPage(String unknownPath) =>
new NotFoundPage(this, unknownPath);
}
class ElementModelPage extends DiagnosticPageWithNav {
String _description;
ElementModelPage(DiagnosticsSite site)
: super(site, 'element', 'Element model',
description: 'The element model for a file.');
@override
String get description => _description ?? super.description;
@override
bool get showInNav => false;
@override
Future<void> generateContent(Map<String, String> params) async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
String path = params['file'];
if (path == null) {
p('No file path provided.');
return;
}
AnalysisDriver driver = server.getAnalysisDriver(path);
if (driver == null) {
p('The file <code>${escape(path)}</code> is not being analyzed.',
raw: true);
return;
}
AnalysisResult result = await driver.getResult(path);
if (result == null) {
p(
'An element model could not be produced for the file '
'<code>${escape(path)}</code>.',
raw: true);
return;
}
ElementWriter writer = new ElementWriter(buf);
result.unit.declaredElement.accept(writer);
}
@override
Future<void> generatePage(Map<String, String> params) async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
try {
_description = params['file'];
await super.generatePage(params);
} finally {
_description = null;
}
}
}
class EnvironmentVariablesPage extends DiagnosticPageWithNav {
EnvironmentVariablesPage(DiagnosticsSite site)
: super(site, 'environment', 'Environment Variables',
description:
'System environment variables as seen from the analysis server.');
@override
Future generateContent(Map<String, String> params) async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
buf.writeln('<table>');
buf.writeln('<tr><th>Variable</th><th>Value</th></tr>');
for (String key in Platform.environment.keys.toList()..sort()) {
String value = Platform.environment[key];
buf.writeln('<tr><td>${escape(key)}</td><td>${escape(value)}</td></tr>');
}
buf.writeln('</table>');
}
}
class ExceptionPage extends DiagnosticPage {
final StackTrace trace;
ExceptionPage(Site site, String message, this.trace)
: super(site, '', '500 Oops', description: message);
Future generateContent(Map<String, String> params) async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
p(trace.toString(), style: 'white-space: pre');
}
}
class ExceptionsPage extends DiagnosticPageWithNav {
ExceptionsPage(DiagnosticsSite site)
: super(site, 'exceptions', 'Exceptions',
description: 'Exceptions from the analysis server.');
Iterable<ServerException> get exceptions => server.exceptions.items;
String get navDetail => printInteger(exceptions.length);
@override
Future generateContent(Map<String, String> params) async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
if (exceptions.isEmpty) {
blankslate('No exceptions encountered!');
} else {
for (ServerException ex in exceptions) {
h3('Exception ${ex.exception}');
p('${escape(ex.message)}<br>${writeOption('fatal', ex.fatal)}',
raw: true);
pre(() {
buf.writeln('<code>${escape(ex.stackTrace.toString())}</code>');
}, classes: "scroll-table");
}
}
}
}
class FeedbackPage extends DiagnosticPage {
FeedbackPage(DiagnosticsSite site)
: super(site, 'feedback', 'Feedback',
description: 'Providing feedback and filing issues.');
@override
Future generateContent(Map<String, String> params) async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
final String issuesUrl = 'https://github.com/dart-lang/sdk/issues';
p(
'To file issues or feature requests, see our '
'<a href="$issuesUrl">bug tracker</a>. When filing an issue, please describe:',
raw: true,
);
ul([
'what you were doing',
'what occured',
'what you think the expected behavior should have been',
], (line) => buf.writeln(line));
List<String> ideInfo = [];
if (server.options.clientId != null) {
ideInfo.add(server.options.clientId);
}
if (server.options.clientVersion != null) {
ideInfo.add(server.options.clientVersion);
}
String ideText = ideInfo.map((str) => '<code>$str</code>').join(', ');
p('Other data to include:');
ul([
"the IDE you are using and it's version${ideText.isEmpty ? '' : ' ($ideText)'}",
'the Dart SDK version (<code>${escape(_sdkVersion)}</code>)',
'your operating system (<code>${escape(Platform.operatingSystem)}</code>)',
], (line) => buf.writeln(line));
p('Thanks!');
}
}
class InstrumentationPage extends DiagnosticPageWithNav {
InstrumentationPage(DiagnosticsSite site)
: super(site, 'instrumentation', 'Instrumentation',
description:
'Verbose instrumentation data from the analysis server.');
@override
Future generateContent(Map<String, String> params) async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
p(
'Instrumentation can be enabled by starting the analysis server with the '
'<code>--instrumentation-log-file=path/to/file</code> flag.',
raw: true);
if (!AnalysisEngine.instance.instrumentationService.isActive) {
blankslate('Instrumentation not active.');
return;
}
h3('Instrumentation');
p('Instrumentation active.');
InstrumentationServer instrumentation =
AnalysisEngine.instance.instrumentationService.instrumentationServer;
String description = instrumentation.describe;
HtmlEscape htmlEscape = new HtmlEscape(HtmlEscapeMode.element);
description = htmlEscape.convert(description);
// Convert http(s): references to hyperlinks.
final RegExp urlRegExp = new RegExp(r'[http|https]+:\/*(\S+)');
description = description.replaceAllMapped(urlRegExp, (Match match) {
return '<a href="${match.group(0)}">${match.group(1)}</a>';
});
p(description.replaceAll('\n', '<br>'), raw: true);
}
}
class MemoryAndCpuPage extends DiagnosticPageWithNav {
final ProcessProfiler profiler;
MemoryAndCpuPage(DiagnosticsSite site, this.profiler)
: super(site, 'memory', 'Memory and CPU Usage',
description: 'Memory and CPU usage for the analysis server.');
DiagnosticDomainHandler get diagnosticDomain {
return server.handlers
.firstWhere((handler) => handler is DiagnosticDomainHandler);
}
@override
Future generateContent(Map<String, String> params) async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
UsageInfo usage = await profiler.getProcessUsage(pid);
developer.ServiceProtocolInfo serviceProtocolInfo =
await developer.Service.getInfo();
if (usage != null) {
buf.writeln(
writeOption('CPU', printPercentage(usage.cpuPercentage / 100.0)));
buf.writeln(
writeOption('Memory', '${printInteger(usage.memoryMB.round())} MB'));
h3('VM');
if (serviceProtocolInfo.serverUri == null) {
p('Service protocol not enabled.');
} else {
p(serviceProtocolInfo.toString());
// http://127.0.0.1:8181/ ==> ws://127.0.0.1:8181/ws
Uri uri = serviceProtocolInfo.serverUri;
uri = uri.replace(scheme: 'ws', path: 'ws');
final ServiceProtocol service = await ServiceProtocol.connect(uri);
final Map vm = await service.call('getVM');
h3('Isolates');
List isolateRefs = vm['isolates'];
for (Map isolateRef in isolateRefs) {
Map isolate =
await service.call('getIsolate', {'isolateId': isolateRef['id']});
Map _heaps = isolate['_heaps'];
int used = 0;
used = _heaps['new']['used'] + _heaps['new']['external'];
used = _heaps['old']['used'] + _heaps['old']['external'];
double usedMB = used / (1024.0 * 1024.0);
int capacity = 0;
capacity = _heaps['new']['capacity'] + _heaps['new']['external'];
capacity = _heaps['old']['capacity'] + _heaps['old']['external'];
double capacityMB = capacity / (1024.0 * 1024.0);
buf.writeln(writeOption(isolate['name'],
'${usedMB.round()} MB of ${capacityMB.round()} MB'));
}
service.dispose();
}
} else {
p('Error retrieving the memory and cpu usage information.');
}
}
}
class NotFoundPage extends DiagnosticPage {
final String path;
NotFoundPage(Site site, this.path)
: super(site, '', '404 Not found', description: "'$path' not found.");
Future generateContent(Map<String, String> params) async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
}
}
class OverlaysPage extends DiagnosticPageWithNav {
OverlaysPage(DiagnosticsSite site)
: super(site, 'overlays', 'Overlays',
description: 'Editing overlays - unsaved file changes.');
@override
Future generateContent(Map<String, String> params) async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
FileContentOverlay overlays = server.fileContentOverlay;
List<String> paths = overlays.paths.toList()..sort();
String overlayPath = params['overlay'];
if (overlayPath != null) {
p(overlayPath);
if (overlays[overlayPath] != null) {
buf.write('<pre><code>');
buf.write(escape(overlays[overlayPath]));
buf.writeln('</code></pre>');
} else {
p('<code>${escape(overlayPath)}</code> not found.', raw: true);
}
return;
}
if (paths.isEmpty) {
blankslate('No overlays.');
} else {
String lenCounter(List list) {
return '<span class="counter" style="float: right;">${list.length}</span>';
}
h3('Overlays ${lenCounter(paths)}', raw: true);
ul(paths, (String overlayPath) {
String uri = '$path?overlay=${Uri.encodeQueryComponent(overlayPath)}';
buf.writeln('<a href="$uri">${escape(overlayPath)}</a>');
});
}
}
}
// TODO(devoncarew): We're not currently tracking the time spent in specific
// lints by default (analysisOptions / driverOptions enableTiming)
class PluginsPage extends DiagnosticPageWithNav {
PluginsPage(DiagnosticsSite site)
: super(site, 'plugins', 'Plugins', description: 'Plugins in use.');
@override
Future generateContent(Map<String, String> params) async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
h3('Analysis plugins');
List<PluginInfo> analysisPlugins = server.pluginManager.plugins;
if (analysisPlugins.isEmpty) {
blankslate('No known analysis plugins.');
} else {
for (PluginInfo plugin in analysisPlugins) {
// TODO(brianwilkerson) Sort the plugins by name.
String id = plugin.pluginId;
PluginData data = plugin.data;
List<String> components = pathPackage.split(id);
int length = components.length;
String name;
if (length == 0) {
name = 'unknown plugin';
} else if (length > 2) {
name = components[length - 3];
} else {
name = components[length - 1];
}
h4(name);
p('bootstrap package path: $id');
if (plugin is DiscoveredPluginInfo) {
p('execution path: ${plugin.executionPath}');
p('packages file path: ${plugin.packagesPath}');
}
if (data.name == null) {
if (plugin.exception != null) {
p('not running');
pre(() {
buf.write(plugin.exception);
});
} else {
p('not running for unknown reason');
}
} else {
p('name: ${data.name}');
p('version: ${data.version}');
p('Associated contexts:');
Set<ContextRoot> contexts = plugin.contextRoots;
if (contexts.isEmpty) {
blankslate('none');
} else {
ul(contexts.toList(), (ContextRoot root) {
buf.writeln(root.root);
});
}
}
}
}
}
}
class ProfilePage extends DiagnosticPageWithNav {
ProfilePage(DiagnosticsSite site)
: super(site, 'profile', 'Profiling Info',
description: 'Profiling performance tag data.');
@override
Future generateContent(Map<String, String> params) async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
h3('Profiling performance tag data');
// prepare sorted tags
List<PerformanceTag> tags = PerformanceTag.all.toList();
tags.remove(ServerPerformanceStatistics.idle);
tags.remove(PerformanceTag.unknown);
tags.removeWhere((tag) => tag.elapsedMs == 0);
tags.sort((a, b) => b.elapsedMs - a.elapsedMs);
// print total time
int totalTime =
tags.fold<int>(0, (int a, PerformanceTag tag) => a + tag.elapsedMs);
p('Total measured time: ${printMilliseconds(totalTime)}');
// draw a pie chart
String rowData =
tags.map((tag) => "['${tag.label}', ${tag.elapsedMs}]").join(',');
buf.writeln(
'<div id="chart-div" style="width: 700px; height: 300px;"></div>');
buf.writeln('''
<script type="text/javascript">
google.charts.load('current', {'packages':['corechart']});
google.charts.setOnLoadCallback(drawChart);
function drawChart() {
var data = new google.visualization.DataTable();
data.addColumn('string', 'Tag');
data.addColumn('number', 'Time (ms)');
data.addRows([$rowData]);
var options = {'title': 'Performance Tag Data', 'width': 700, 'height': 300};
var chart = new google.visualization.PieChart(document.getElementById('chart-div'));
chart.draw(data, options);
}
</script>
''');
// write out a table
void _writeRow(List<String> data, {bool header: false}) {
buf.write('<tr>');
if (header) {
for (String d in data) {
buf.write('<th>$d</th>');
}
} else {
buf.write('<td>${data[0]}</td>');
for (String d in data.sublist(1)) {
buf.write('<td class="right">$d</td>');
}
}
buf.writeln('</tr>');
}
buf.write('<table>');
_writeRow(['Tag name', 'Time (in ms)', 'Percent'], header: true);
void writeRow(PerformanceTag tag) {
double percent = tag.elapsedMs / totalTime;
_writeRow([
tag.label,
printMilliseconds(tag.elapsedMs),
printPercentage(percent)
]);
}
tags.forEach(writeRow);
buf.write('</table>');
if (_showLints) {
h3('Lint rule timings');
List<LintRule> rules = Registry.ruleRegistry.rules.toList();
int totalLintTime = rules.fold(0,
(sum, rule) => sum + lintRegistry.getTimer(rule).elapsedMilliseconds);
p('Total time spent in lints: ${printMilliseconds(totalLintTime)}');
rules.sort((first, second) {
int firstTime = lintRegistry.getTimer(first).elapsedMilliseconds;
int secondTime = lintRegistry.getTimer(second).elapsedMilliseconds;
if (firstTime == secondTime) {
return first.lintCode.name.compareTo(second.lintCode.name);
}
return secondTime - firstTime;
});
buf.write('<table>');
_writeRow(['Lint code', 'Time (in ms)'], header: true);
for (var rule in rules) {
int time = lintRegistry.getTimer(rule).elapsedMilliseconds;
_writeRow([rule.lintCode.name, printMilliseconds(time)]);
}
buf.write('</table>');
}
}
}
class ServiceProtocol {
final WebSocket socket;
int _id = 0;
Map<String, Completer<Map>> _completers = {};
ServiceProtocol._(this.socket) {
socket.listen(_handleMessage);
}
Future<Map> call(String method, [Map args]) {
String id = '${++_id}';
Completer<Map> completer = new Completer();
_completers[id] = completer;
Map m = {'id': id, 'method': method};
if (args != null) m['params'] = args;
String message = jsonEncode(m);
socket.add(message);
return completer.future;
}
Future dispose() => socket.close();
void _handleMessage(dynamic message) {
if (message is! String) {
return;
}
try {
dynamic json = jsonDecode(message);
if (json.containsKey('id')) {
dynamic id = json['id'];
_completers[id]?.complete(json['result']);
_completers.remove(id);
}
} catch (e) {
// ignore
}
}
static Future<ServiceProtocol> connect(Uri uri) async {
WebSocket socket = await WebSocket.connect(uri.toString());
return new ServiceProtocol._(socket);
}
}
class StatusPage extends DiagnosticPageWithNav {
StatusPage(DiagnosticsSite site)
: super(site, 'status', 'Status',
description:
'General status and diagnostics for the analysis server.');
@override
Future generateContent(Map<String, String> params) async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
DiagnosticsSite diagnosticsSite = site;
buf.writeln('<div class="columns">');
buf.writeln('<div class="column one-half">');
h3('Status');
buf.writeln(writeOption('Use fasta parser',
diagnosticsSite.socketServer.analysisServerOptions.useFastaParser));
buf.writeln(writeOption('Instrumentation enabled',
AnalysisEngine.instance.instrumentationService.isActive));
bool uxExp1 =
diagnosticsSite.socketServer.analysisServerOptions.enableUXExperiment1;
bool uxExp2 =
diagnosticsSite.socketServer.analysisServerOptions.enableUXExperiment2;
if (uxExp1 || uxExp2) {
buf.writeln(writeOption('UX Experiment 1', uxExp1));
buf.writeln(writeOption('ux Experiment 2', uxExp2));
}
buf.writeln(writeOption('Server process ID', pid));
buf.writeln('</div>');
buf.writeln('<div class="column one-half">');
h3('Versions');
buf.writeln(writeOption('Analysis server version', AnalysisServer.VERSION));
buf.writeln(writeOption('Dart SDK', Platform.version));
buf.writeln('</div>');
buf.writeln('</div>');
List<String> lines = (site as DiagnosticsSite).lastPrintedLines;
if (lines.isNotEmpty) {
h3('Debug output');
p(lines.join('\n'), style: 'white-space: pre');
}
}
}
class SubscriptionsPage extends DiagnosticPageWithNav {
SubscriptionsPage(DiagnosticsSite site)
: super(site, 'subscriptions', 'Subscriptions',
description: 'Registered subscriptions to analysis server events.');
@override
Future generateContent(Map<String, String> params) async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
// server domain
h3('Server domain subscriptions');
ul(ServerService.VALUES, (item) {
if (server.serverServices.contains(item)) {
buf.write('$item (has subscriptions)');
} else {
buf.write('$item (no subscriptions)');
}
});
// analysis domain
h3('Analysis domain subscriptions');
for (AnalysisService service in AnalysisService.VALUES) {
buf.writeln('${service.name}<br>');
ul(server.analysisServices[service] ?? [], (item) {
buf.write('$item');
});
}
}
}