diff --git a/DEPS b/DEPS
index 3e26472..14eb54e 100644
--- a/DEPS
+++ b/DEPS
@@ -109,7 +109,7 @@
   # For more details, see https://github.com/dart-lang/sdk/issues/30164
   "dart_style_rev": "6f894c0ca33686122be9085f06e5b9bf6ad55262",
 
-  "dartdoc_rev" : "b3927dd89d6ff9c78dc88ab2901e63b6a3bf29b7",
+  "dartdoc_rev" : "57761bb61e455eedf93e18c99082445f82116300",
   "devtools_rev" : "2970d4eab8b8e023ac0779090ed17ae391418b9b",
   "ffi_rev": "4dd32429880a57b64edaf54c9d5af8a9fa9a4ffb",
   "fixnum_rev": "848341f061359ef7ddc0cad472c2ecbb036b28ac",
diff --git a/pkg/analysis_server/test/integration/support/integration_tests.dart b/pkg/analysis_server/test/integration/support/integration_tests.dart
index 3ef73c2..46858e0 100644
--- a/pkg/analysis_server/test/integration/support/integration_tests.dart
+++ b/pkg/analysis_server/test/integration/support/integration_tests.dart
@@ -521,11 +521,11 @@
       var trimmedLine = line.trim();
 
       // Guard against lines like:
-      //   {"event":"server.connected","params":{...}}Observatory listening on ...
-      var observatoryMessage = 'Observatory listening on ';
-      if (trimmedLine.contains(observatoryMessage)) {
+      //   {"event":"server.connected","params":{...}}The Dart VM service is listening on ...
+      var dartVMServiceMessage = 'The Dart VM service is listening on ';
+      if (trimmedLine.contains(dartVMServiceMessage)) {
         trimmedLine = trimmedLine
-            .substring(0, trimmedLine.indexOf(observatoryMessage))
+            .substring(0, trimmedLine.indexOf(dartVMServiceMessage))
             .trim();
       }
       if (trimmedLine.isEmpty) {
diff --git a/pkg/analysis_server/test/stress/utilities/server.dart b/pkg/analysis_server/test/stress/utilities/server.dart
index b2eefa3..68ef712 100644
--- a/pkg/analysis_server/test/stress/utilities/server.dart
+++ b/pkg/analysis_server/test/stress/utilities/server.dart
@@ -762,7 +762,7 @@
 
     var trimmedLine = line.trim();
     if (trimmedLine.isEmpty ||
-        trimmedLine.startsWith('Observatory listening on ')) {
+        trimmedLine.startsWith('The Dart VM service is listening on ')) {
       return;
     }
     logger?.log(fromServer, '$trimmedLine');
diff --git a/pkg/analysis_server_client/lib/src/server_base.dart b/pkg/analysis_server_client/lib/src/server_base.dart
index dd9668c..34f3f2e 100644
--- a/pkg/analysis_server_client/lib/src/server_base.dart
+++ b/pkg/analysis_server_client/lib/src/server_base.dart
@@ -113,11 +113,11 @@
     var trimmedLine = line.trim();
 
     // Guard against lines like:
-    //   {"event":"server.connected","params":{...}}Observatory listening on ...
-    const observatoryMessage = 'Observatory listening on ';
-    if (trimmedLine.contains(observatoryMessage)) {
+    //   {"event":"server.connected","params":{...}}The Dart VM service is listening on ...
+    const dartVMServiceMessage = 'The Dart VM service is listening on ';
+    if (trimmedLine.contains(dartVMServiceMessage)) {
       trimmedLine = trimmedLine
-          .substring(0, trimmedLine.indexOf(observatoryMessage))
+          .substring(0, trimmedLine.indexOf(dartVMServiceMessage))
           .trim();
     }
     if (trimmedLine.isEmpty) {
diff --git a/pkg/analysis_server_client/test/server_test.dart b/pkg/analysis_server_client/test/server_test.dart
index 286938d..504f9f0 100644
--- a/pkg/analysis_server_client/test/server_test.dart
+++ b/pkg/analysis_server_client/test/server_test.dart
@@ -173,7 +173,7 @@
 };
 
 Stream<List<int>> _badMessage() async* {
-  yield utf8.encoder.convert('Observatory listening on foo bar\n');
+  yield utf8.encoder.convert('The Dart VM service is listening on foo bar\n');
   final sampleJson = {
     'id': '0',
     'error': _badErrorMessage,
@@ -182,7 +182,7 @@
 }
 
 Stream<List<int>> _eventMessage() async* {
-  yield utf8.encoder.convert('Observatory listening on foo bar\n');
+  yield utf8.encoder.convert('The Dart VM service is listening on foo bar\n');
   final sampleJson = {
     'event': 'fooEvent',
     'params': {'foo': 'bar', 'baz': 'bang'}
@@ -191,7 +191,7 @@
 }
 
 Stream<List<int>> _goodMessage() async* {
-  yield utf8.encoder.convert('Observatory listening on foo bar\n');
+  yield utf8.encoder.convert('The Dart VM service is listening on foo bar\n');
   final sampleJson = {
     'id': '0',
     'result': {'foo': 'bar'}
diff --git a/pkg/analyzer_plugin/test/integration/support/integration_tests.dart b/pkg/analyzer_plugin/test/integration/support/integration_tests.dart
index 8fd6bff..52dbfbd 100644
--- a/pkg/analyzer_plugin/test/integration/support/integration_tests.dart
+++ b/pkg/analyzer_plugin/test/integration/support/integration_tests.dart
@@ -443,7 +443,7 @@
         .listen((String line) {
       lastCommunicationTime = currentElapseTime;
       var trimmedLine = line.trim();
-      if (trimmedLine.startsWith('Observatory listening on ')) {
+      if (trimmedLine.startsWith('The Dart VM service is listening on ')) {
         return;
       }
       _recordStdio('RECV: $trimmedLine');
diff --git a/pkg/compiler/lib/src/ssa/nodes.dart b/pkg/compiler/lib/src/ssa/nodes.dart
index fa96a89..2026528 100644
--- a/pkg/compiler/lib/src/ssa/nodes.dart
+++ b/pkg/compiler/lib/src/ssa/nodes.dart
@@ -1096,6 +1096,8 @@
   static const int TYPE_BIND_TYPECODE = 57;
 
   static const int IS_LATE_SENTINEL_TYPECODE = 58;
+  static const int STRING_CONCAT_TYPECODE = 59;
+  static const int STRINGIFY_TYPECODE = 60;
 
   HInstruction(this.inputs, this.instructionType) {
     assert(inputs.every((e) => e != null), "inputs: $inputs");
@@ -3742,10 +3744,7 @@
 class HStringConcat extends HInstruction {
   HStringConcat(HInstruction left, HInstruction right, AbstractValue type)
       : super([left, right], type) {
-    // TODO(sra): Until Issue 9293 is fixed, this false dependency keeps the
-    // concats bunched with stringified inputs for much better looking code with
-    // fewer temps.
-    sideEffects.setDependsOnSomething();
+    setUseGvn();
   }
 
   HInstruction get left => inputs[0];
@@ -3755,6 +3754,13 @@
   accept(HVisitor visitor) => visitor.visitStringConcat(this);
   @override
   toString() => "string concat";
+
+  @override
+  int typeCode() => HInstruction.STRING_CONCAT_TYPECODE;
+  @override
+  bool typeEquals(HInstruction other) => other is HStringConcat;
+  @override
+  bool dataEquals(HStringConcat other) => true;
 }
 
 /// The part of string interpolation which converts and interpolated expression
@@ -3771,6 +3777,7 @@
     sideEffects.clearAllDependencies();
     sideEffects.clearAllSideEffects();
     _isPure = true;
+    setUseGvn();
   }
 
   @override
@@ -3780,6 +3787,13 @@
   accept(HVisitor visitor) => visitor.visitStringify(this);
   @override
   toString() => "stringify";
+
+  @override
+  int typeCode() => HInstruction.STRINGIFY_TYPECODE;
+  @override
+  bool typeEquals(HInstruction other) => other is HStringify;
+  @override
+  bool dataEquals(HStringify other) => this._isPure == other._isPure;
 }
 
 /// Non-block-based (aka. traditional) loop information.
diff --git a/pkg/dartdev/lib/src/commands/doc.dart b/pkg/dartdev/lib/src/commands/doc.dart
index 9a9c4a2..fb9d38a 100644
--- a/pkg/dartdev/lib/src/commands/doc.dart
+++ b/pkg/dartdev/lib/src/commands/doc.dart
@@ -90,7 +90,7 @@
       if (verbose) ...['--verbose-warnings', '--show-stats'],
     ]);
 
-    final config = await parseOptions(pubPackageMetaProvider, options);
+    final config = parseOptions(pubPackageMetaProvider, options);
     if (config == null) {
       // There was an error while parsing options.
       return 2;
@@ -105,7 +105,7 @@
         config, pubPackageMetaProvider, packageConfigProvider);
     final dartdoc = config.generateDocs
         ? await Dartdoc.fromContext(config, packageBuilder)
-        : await Dartdoc.withEmptyGenerator(config, packageBuilder);
+        : Dartdoc.withEmptyGenerator(config, packageBuilder);
     dartdoc.executeGuarded();
     return 0;
   }
diff --git a/pkg/dartdev/test/commands/run_test.dart b/pkg/dartdev/test/commands/run_test.dart
index 40978d9..23e575f 100644
--- a/pkg/dartdev/test/commands/run_test.dart
+++ b/pkg/dartdev/test/commands/run_test.dart
@@ -14,7 +14,8 @@
 const String soundNullSafetyMessage = 'Info: Compiling with sound null safety';
 const devToolsMessagePrefix =
     'The Dart DevTools debugger and profiler is available at: http://127.0.0.1:';
-const observatoryMessagePrefix = 'Observatory listening on http://127.0.0.1:';
+const dartVMServiceMessagePrefix =
+    'The Dart VM service is listening on http://127.0.0.1:';
 
 void main() {
   group('run', run, timeout: longTimeout);
@@ -214,7 +215,7 @@
     expect(
       result.stdout,
       matches(
-          r'Observatory listening on http:\/\/127.0.0.1:8181\/[a-zA-Z0-9_-]+=\/\n.*'),
+          r'The Dart VM service is listening on http:\/\/127.0.0.1:8181\/[a-zA-Z0-9_-]+=\/\n.*'),
     );
     expect(result.stderr, isEmpty);
     expect(result.exitCode, 0);
@@ -236,7 +237,7 @@
 
     expect(
       result.stdout,
-      contains('Observatory listening on http://127.0.0.1:8181/\n'),
+      contains('The Dart VM service is listening on http://127.0.0.1:8181/\n'),
     );
     expect(result.stderr, isEmpty);
     expect(result.exitCode, 0);
@@ -258,7 +259,7 @@
     expect(
       result.stdout,
       matches(
-          r'Observatory listening on http:\/\/\[::1\]:8181\/[a-zA-Z0-9_-]+=\/\n.*'),
+          r'The Dart VM service is listening on http:\/\/\[::1\]:8181\/[a-zA-Z0-9_-]+=\/\n.*'),
     );
     expect(result.stderr, isEmpty);
     expect(result.exitCode, 0);
@@ -361,7 +362,7 @@
           p.relativeFilePath,
         ]);
         expect(result.stdout, isNot(contains(devToolsMessagePrefix)));
-        expect(result.stdout, contains(observatoryMessagePrefix));
+        expect(result.stdout, contains(dartVMServiceMessagePrefix));
       });
 
       test('dart simple', () async {
@@ -372,7 +373,7 @@
           p.relativeFilePath,
         ]);
         expect(result.stdout, isNot(contains(devToolsMessagePrefix)));
-        expect(result.stdout, contains(observatoryMessagePrefix));
+        expect(result.stdout, contains(dartVMServiceMessagePrefix));
       });
     });
 
@@ -386,7 +387,7 @@
           p.relativeFilePath,
         ]);
         expect(result.stdout, contains(devToolsMessagePrefix));
-        expect(result.stdout, contains(observatoryMessagePrefix));
+        expect(result.stdout, contains(dartVMServiceMessagePrefix));
       });
 
       test('dart simple', () async {
@@ -397,7 +398,7 @@
           p.relativeFilePath,
         ]);
         expect(result.stdout, contains(devToolsMessagePrefix));
-        expect(result.stdout, contains(observatoryMessagePrefix));
+        expect(result.stdout, contains(dartVMServiceMessagePrefix));
       });
     });
   });
diff --git a/pkg/dds/test/dap/integration/debug_attach_test.dart b/pkg/dds/test/dap/integration/debug_attach_test.dart
index 810a15f..846b3db 100644
--- a/pkg/dds/test/dap/integration/debug_attach_test.dart
+++ b/pkg/dds/test/dap/integration/debug_attach_test.dart
@@ -50,7 +50,7 @@
           // The stdout also contains the Observatory+DevTools banners.
           .where(
             (line) =>
-                !line.startsWith('Observatory listening on') &&
+                !line.startsWith('The Dart VM service is listening on') &&
                 !line.startsWith(
                     'The Dart DevTools debugger and profiler is available at'),
           )
@@ -103,7 +103,7 @@
           // The stdout also contains the Observatory+DevTools banners.
           .where(
             (line) =>
-                !line.startsWith('Observatory listening on') &&
+                !line.startsWith('The Dart VM service is listening on') &&
                 !line.startsWith(
                     'The Dart DevTools debugger and profiler is available at'),
           )
diff --git a/pkg/dds/test/dap/integration/test_support.dart b/pkg/dds/test/dap/integration/test_support.dart
index 7a55bb2..1c0dc21 100644
--- a/pkg/dds/test/dap/integration/test_support.dart
+++ b/pkg/dds/test/dap/integration/test_support.dart
@@ -44,9 +44,10 @@
 /// an authentication token.
 final vmServiceAuthCodePathPattern = RegExp(r'^/[\w_\-=]{5,15}/ws$');
 
-/// A [RegExp] that matches the "Observatory listening on" banner that is sent
+/// A [RegExp] that matches the "The Dart VM service is listening on" banner that is sent
 /// by the VM when not using --write-service-info.
-final vmServiceBannerPattern = RegExp(r'Observatory listening on ([^\s]+)\s');
+final vmServiceBannerPattern =
+    RegExp(r'The Dart VM service is listening on ([^\s]+)\s');
 
 /// The root of the SDK containing the current running VM.
 final sdkRoot = path.dirname(path.dirname(Platform.resolvedExecutable));
diff --git a/pkg/front_end/test/hot_reload_e2e_test.dart b/pkg/front_end/test/hot_reload_e2e_test.dart
index 07cf63b..aa8e855 100644
--- a/pkg/front_end/test/hot_reload_e2e_test.dart
+++ b/pkg/front_end/test/hot_reload_e2e_test.dart
@@ -86,8 +86,8 @@
 
   Future<int> computeVmPort() async {
     var portLine = await lines[0];
-    Expect.isTrue(observatoryPortRegExp.hasMatch(portLine));
-    var match = observatoryPortRegExp.firstMatch(portLine);
+    Expect.isTrue(dartVMServicePortRegExp.hasMatch(portLine));
+    var match = dartVMServicePortRegExp.firstMatch(portLine);
     return int.parse(match!.group(1)!);
   }
 
@@ -384,5 +384,5 @@
 void g() {}
 ''';
 
-RegExp observatoryPortRegExp =
-    new RegExp("Observatory listening on http://127.0.0.1:\([0-9]*\)/");
+RegExp dartVMServicePortRegExp = new RegExp(
+    "The Dart VM service is listening on http://127.0.0.1:\([0-9]*\)/");
diff --git a/pkg/front_end/test/vm_service_helper.dart b/pkg/front_end/test/vm_service_helper.dart
index f2d3cb6..ac33557 100644
--- a/pkg/front_end/test/vm_service_helper.dart
+++ b/pkg/front_end/test/vm_service_helper.dart
@@ -166,10 +166,10 @@
         .transform(utf8.decoder)
         .transform(new LineSplitter())
         .listen((line) {
-      const kObservatoryListening = 'Observatory listening on ';
-      if (line.startsWith(kObservatoryListening)) {
+      const kDartVMServiceListening = 'The Dart VM service is listening on ';
+      if (line.startsWith(kDartVMServiceListening)) {
         Uri observatoryUri =
-            Uri.parse(line.substring(kObservatoryListening.length));
+            Uri.parse(line.substring(kDartVMServiceListening.length));
         _setupAndRun(observatoryUri).catchError((e, st) {
           // Manually kill the process or it will leak,
           // see http://dartbug.com/42918
diff --git a/pkg/front_end/test/weekly_tester.dart b/pkg/front_end/test/weekly_tester.dart
index 077210e..5f52e98 100644
--- a/pkg/front_end/test/weekly_tester.dart
+++ b/pkg/front_end/test/weekly_tester.dart
@@ -169,7 +169,7 @@
       .transform(new LineSplitter())
       .listen((line) {
     print("$id stderr> $line");
-    if (line.contains("Observatory listening on")) {
+    if (line.contains("The Dart VM service is listening on")) {
       observatoryLines.add(line);
     }
   });
@@ -178,7 +178,7 @@
       .transform(new LineSplitter())
       .listen((line) {
     print("$id stdout> $line");
-    if (line.contains("Observatory listening on")) {
+    if (line.contains("The Dart VM service is listening on")) {
       observatoryLines.add(line);
     }
   });
diff --git a/pkg/vm/test/incremental_compiler_test.dart b/pkg/vm/test/incremental_compiler_test.dart
index ef627ac..6e0473c 100644
--- a/pkg/vm/test/incremental_compiler_test.dart
+++ b/pkg/vm/test/incremental_compiler_test.dart
@@ -499,9 +499,9 @@
         list.path
       ]);
 
-      const kObservatoryListening = 'Observatory listening on ';
-      final RegExp observatoryPortRegExp =
-          new RegExp("Observatory listening on http://127.0.0.1:\([0-9]*\)");
+      const kDartVMServiceListening = 'The Dart VM service is listening on ';
+      final RegExp dartVMServicePortRegExp = new RegExp(
+          "The Dart VM service is listening on http://127.0.0.1:\([0-9]*\)");
       int port;
       final splitter = new LineSplitter();
       Completer<String> portLineCompleter = new Completer<String>();
@@ -509,9 +509,9 @@
           .transform(utf8.decoder)
           .transform(splitter)
           .listen((String s) async {
-        if (s.startsWith(kObservatoryListening)) {
-          expect(observatoryPortRegExp.hasMatch(s), isTrue);
-          final match = observatoryPortRegExp.firstMatch(s)!;
+        if (s.startsWith(kDartVMServiceListening)) {
+          expect(dartVMServicePortRegExp.hasMatch(s), isTrue);
+          final match = dartVMServicePortRegExp.firstMatch(s)!;
           port = int.parse(match.group(1)!);
           await collectAndCheckCoverageData(port, true);
           if (!portLineCompleter.isCompleted) {
@@ -603,9 +603,9 @@
         list.path
       ]);
 
-      const kObservatoryListening = 'Observatory listening on ';
-      final RegExp observatoryPortRegExp =
-          new RegExp("Observatory listening on http://127.0.0.1:\([0-9]*\)");
+      const kDartVMServiceListening = 'The Dart VM service is listening on ';
+      final RegExp dartVMServicePortRegExp = new RegExp(
+          "The Dart VM service is listening on http://127.0.0.1:\([0-9]*\)");
       int port;
       final splitter = new LineSplitter();
       Completer<String> portLineCompleter = new Completer<String>();
@@ -618,9 +618,9 @@
         if (s == expectStdoutContains) {
           foundExpectedString = true;
         }
-        if (s.startsWith(kObservatoryListening)) {
-          expect(observatoryPortRegExp.hasMatch(s), isTrue);
-          final match = observatoryPortRegExp.firstMatch(s)!;
+        if (s.startsWith(kDartVMServiceListening)) {
+          expect(dartVMServicePortRegExp.hasMatch(s), isTrue);
+          final match = dartVMServicePortRegExp.firstMatch(s)!;
           port = int.parse(match.group(1)!);
           await collectAndCheckCoverageData(port, true,
               onGetAllVerifyCount: false, coverageForLines: coverageLines);
@@ -869,9 +869,9 @@
         list.path
       ]);
 
-      const kObservatoryListening = 'Observatory listening on ';
-      final RegExp observatoryPortRegExp =
-          new RegExp("Observatory listening on http://127.0.0.1:\([0-9]*\)");
+      const kDartVMServiceListening = 'The Dart VM service is listening on ';
+      final RegExp dartVMServicePortRegExp = new RegExp(
+          "The Dart VM service is listening on http://127.0.0.1:\([0-9]*\)");
       int port;
       final splitter = new LineSplitter();
       Completer<String> portLineCompleter = new Completer<String>();
@@ -879,9 +879,9 @@
           .transform(utf8.decoder)
           .transform(splitter)
           .listen((String s) async {
-        if (s.startsWith(kObservatoryListening)) {
-          expect(observatoryPortRegExp.hasMatch(s), isTrue);
-          final match = observatoryPortRegExp.firstMatch(s)!;
+        if (s.startsWith(kDartVMServiceListening)) {
+          expect(dartVMServicePortRegExp.hasMatch(s), isTrue);
+          final match = dartVMServicePortRegExp.firstMatch(s)!;
           port = int.parse(match.group(1)!);
           Set<int> hits1 =
               await collectAndCheckCoverageData(port, true, resume: false);
@@ -972,10 +972,10 @@
 
       String portLine = await portLineCompleter.future;
 
-      final RegExp observatoryPortRegExp =
-          new RegExp("Observatory listening on http://127.0.0.1:\([0-9]*\)");
-      expect(observatoryPortRegExp.hasMatch(portLine), isTrue);
-      final match = observatoryPortRegExp.firstMatch(portLine)!;
+      final RegExp dartVMServicePortRegExp = new RegExp(
+          "The Dart VM service is listening on http://127.0.0.1:\([0-9]*\)");
+      expect(dartVMServicePortRegExp.hasMatch(portLine), isTrue);
+      final match = dartVMServicePortRegExp.firstMatch(portLine)!;
       final port = int.parse(match.group(1)!);
 
       var remoteVm = new RemoteVm(port);
@@ -1256,9 +1256,9 @@
         scriptOrDill.path
       ]);
 
-      const kObservatoryListening = 'Observatory listening on ';
-      final RegExp observatoryPortRegExp =
-          new RegExp("Observatory listening on http://127.0.0.1:\([0-9]*\)");
+      const kDartVMServiceListening = 'The Dart VM service is listening on ';
+      final RegExp dartVMServicePortRegExp = new RegExp(
+          "The Dart VM service is listening on http://127.0.0.1:\([0-9]*\)");
       int port;
       final splitter = new LineSplitter();
       Completer<String> portLineCompleter = new Completer<String>();
@@ -1267,9 +1267,9 @@
           .transform(splitter)
           .listen((String s) async {
         print("vm stdout: $s");
-        if (s.startsWith(kObservatoryListening)) {
-          expect(observatoryPortRegExp.hasMatch(s), isTrue);
-          final match = observatoryPortRegExp.firstMatch(s)!;
+        if (s.startsWith(kDartVMServiceListening)) {
+          expect(dartVMServicePortRegExp.hasMatch(s), isTrue);
+          final match = dartVMServicePortRegExp.firstMatch(s)!;
           port = int.parse(match.group(1)!);
           RemoteVm remoteVm = new RemoteVm(port);
 
diff --git a/pkg/vm_service/test/common/test_helper.dart b/pkg/vm_service/test/common/test_helper.dart
index 8415c74..7561ce0 100644
--- a/pkg/vm_service/test/common/test_helper.dart
+++ b/pkg/vm_service/test/common/test_helper.dart
@@ -205,9 +205,9 @@
           .transform(utf8.decoder)
           .transform(LineSplitter())
           .listen((line) {
-        const kObservatoryListening = 'Observatory listening on ';
-        if (line.startsWith(kObservatoryListening)) {
-          uri = Uri.parse(line.substring(kObservatoryListening.length));
+        const kDartVMServiceListening = 'The Dart VM service is listening on ';
+        if (line.startsWith(kDartVMServiceListening)) {
+          uri = Uri.parse(line.substring(kDartVMServiceListening.length));
         }
         if (pause_on_start || line == '') {
           // Received blank line.
diff --git a/runtime/bin/main_options.cc b/runtime/bin/main_options.cc
index 83c1408..9c03b89 100644
--- a/runtime/bin/main_options.cc
+++ b/runtime/bin/main_options.cc
@@ -168,7 +168,7 @@
 "--write-service-info=<file_uri>\n"
 "  Outputs information necessary to connect to the VM service to the\n"
 "  specified file in JSON format. Useful for clients which are unable to\n"
-"  listen to stdout for the Observatory listening message.\n"
+"  listen to stdout for the Dart VM service listening message.\n"
 #endif  // !defined(PRODUCT)
 "--snapshot-kind=<snapshot_kind>\n"
 "--snapshot=<file_name>\n"
diff --git a/runtime/observatory/tests/service/sigquit_starts_service_test.dart b/runtime/observatory/tests/service/sigquit_starts_service_test.dart
index 911c12d..357a986 100644
--- a/runtime/observatory/tests/service/sigquit_starts_service_test.dart
+++ b/runtime/observatory/tests/service/sigquit_starts_service_test.dart
@@ -23,7 +23,7 @@
     sub = process.stdout.transform(utf8.decoder).listen((e) async {
       if (e.contains('ready') && !readyCompleter.isCompleted) {
         readyCompleter.complete();
-      } else if (e.contains('Observatory listening on')) {
+      } else if (e.contains('The Dart VM service is listening on')) {
         await sub.cancel();
         completer.complete();
       }
diff --git a/runtime/observatory_2/tests/service_2/sigquit_starts_service_test.dart b/runtime/observatory_2/tests/service_2/sigquit_starts_service_test.dart
index b056477..7320f09 100644
--- a/runtime/observatory_2/tests/service_2/sigquit_starts_service_test.dart
+++ b/runtime/observatory_2/tests/service_2/sigquit_starts_service_test.dart
@@ -23,7 +23,7 @@
     sub = process.stdout.transform(utf8.decoder).listen((e) async {
       if (e.contains('ready') && !readyCompleter.isCompleted) {
         readyCompleter.complete();
-      } else if (e.contains('Observatory listening on')) {
+      } else if (e.contains('The Dart VM service is listening on')) {
         await sub.cancel();
         completer.complete();
       }
diff --git a/runtime/tests/vm/dart_2/isolates/reload_utils.dart b/runtime/tests/vm/dart_2/isolates/reload_utils.dart
index c973017..c1c9e96 100644
--- a/runtime/tests/vm/dart_2/isolates/reload_utils.dart
+++ b/runtime/tests/vm/dart_2/isolates/reload_utils.dart
@@ -166,7 +166,7 @@
   }
 
   Future _waitUntilService() async {
-    final needle = 'Observatory listening on ';
+    final needle = 'The Dart VM service is listening on ';
     final line = await waitUntilStdoutContains(needle);
     final Uri uri = Uri.parse(line.substring(needle.length));
     assert(_remoteVm == null);
diff --git a/runtime/vm/service.cc b/runtime/vm/service.cc
index 336cd88..b761a93 100644
--- a/runtime/vm/service.cc
+++ b/runtime/vm/service.cc
@@ -1205,9 +1205,9 @@
   if (!ServiceIsolate::IsRunning()) {
     OS::PrintErr("  Start the vm-service to debug.\n");
   } else if (ServiceIsolate::server_address() == NULL) {
-    OS::PrintErr("  Connect to Observatory to debug.\n");
+    OS::PrintErr("  Connect to the Dart VM service to debug.\n");
   } else {
-    OS::PrintErr("  Connect to Observatory at %s to debug.\n",
+    OS::PrintErr("  Connect to the Dart VM service at %s to debug.\n",
                  ServiceIsolate::server_address());
   }
   const Error& err = Error::Handle(Thread::Current()->sticky_error());
diff --git a/sdk/lib/_internal/vm/bin/vmservice_server.dart b/sdk/lib/_internal/vm/bin/vmservice_server.dart
index c8e61b2..f804398 100644
--- a/sdk/lib/_internal/vm/bin/vmservice_server.dart
+++ b/sdk/lib/_internal/vm/bin/vmservice_server.dart
@@ -4,10 +4,12 @@
 
 part of vmservice_io;
 
+// TODO(bkonyi): deprecate SILENT_OBSERVATORY in favor of SILENT_VM_SERVICE
 bool silentObservatory = bool.fromEnvironment('SILENT_OBSERVATORY');
+bool silentVMService = bool.fromEnvironment('SILENT_VM_SERVICE');
 
 void serverPrint(String s) {
-  if (silentObservatory) {
+  if (silentObservatory || silentVMService) {
     // We've been requested to be silent.
     return;
   }
@@ -436,9 +438,10 @@
     final maxAttempts = 10;
     while (!await poll()) {
       attempts++;
-      serverPrint('Observatory server failed to start after $attempts tries');
+      serverPrint(
+          'Dart VM service server failed to start after $attempts tries');
       if (attempts > maxAttempts) {
-        serverPrint('Could not start Observatory HTTP server:\n'
+        serverPrint('Could not start Dart VM service HTTP server:\n'
             '$pollError\n$pollStack\n');
         _notifyServerState('');
         onServerAddressChange(null);
@@ -451,7 +454,7 @@
       await Future<void>.delayed(const Duration(seconds: 1));
     }
     if (_service.isExiting) {
-      serverPrint('Observatory HTTP server exiting before listening as '
+      serverPrint('Dart VM service HTTP server exiting before listening as '
           'vm service has received exit request\n');
       await shutdown(true);
       return this;
@@ -468,7 +471,7 @@
   }
 
   Future<void> outputConnectionInformation() async {
-    serverPrint('Observatory listening on $serverAddress');
+    serverPrint('The Dart VM service is listening on $serverAddress');
     if (Platform.isFuchsia) {
       // Create a file with the port number.
       final tmp = Directory.systemTemp.path;
@@ -507,14 +510,14 @@
     // Shutdown HTTP server and subscription.
     Uri oldServerAddress = serverAddress!;
     return cleanup(forced).then((_) {
-      serverPrint('Observatory no longer listening on $oldServerAddress');
+      serverPrint('Dart VM service no longer listening on $oldServerAddress');
       _server = null;
       _notifyServerState('');
       onServerAddressChange(null);
       return this;
     }).catchError((e, st) {
       _server = null;
-      serverPrint('Could not shutdown Observatory HTTP server:\n$e\n$st\n');
+      serverPrint('Could not shutdown Dart VM service HTTP server:\n$e\n$st\n');
       _notifyServerState('');
       onServerAddressChange(null);
       return this;
diff --git a/tools/VERSION b/tools/VERSION
index aeefac4..a502dde 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 17
 PATCH 0
-PRERELEASE 125
+PRERELEASE 126
 PRERELEASE_PATCH 0
\ No newline at end of file
