diff --git a/src/harness/harnessLanguageService.ts b/src/harness/harnessLanguageService.ts
index 994ebe67e0cd1..af5a998df99b2 100644
--- a/src/harness/harnessLanguageService.ts
+++ b/src/harness/harnessLanguageService.ts
@@ -681,11 +681,11 @@ namespace Harness.LanguageService {
         }
 
         info(message: string): void {
-            return this.host.log(message);
+            this.host.log(message);
         }
 
-        msg(message: string) {
-            return this.host.log(message);
+        err(message: string): void {
+            this.host.log(message);
         }
 
         loggingEnabled() {
@@ -700,17 +700,12 @@ namespace Harness.LanguageService {
             return false;
         }
 
-
-        endGroup(): void {
-        }
+        group() { throw ts.notImplemented(); }
 
         perftrc(message: string): void {
             return this.host.log(message);
         }
 
-        startGroup(): void {
-        }
-
         setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]): any {
             return setTimeout(callback, ms, args);
         }
diff --git a/src/harness/unittests/cachingInServerLSHost.ts b/src/harness/unittests/cachingInServerLSHost.ts
index eb2907e89dea6..92c10c1ff6d5e 100644
--- a/src/harness/unittests/cachingInServerLSHost.ts
+++ b/src/harness/unittests/cachingInServerLSHost.ts
@@ -52,21 +52,9 @@ namespace ts {
     }
 
     function createProject(rootFile: string, serverHost: server.ServerHost): { project: server.Project, rootScriptInfo: server.ScriptInfo } {
-        const logger: server.Logger = {
-            close: noop,
-            hasLevel: () => false,
-            loggingEnabled: () => false,
-            perftrc: noop,
-            info: noop,
-            startGroup: noop,
-            endGroup: noop,
-            msg: noop,
-            getLogFileName: (): string => undefined
-        };
-
         const svcOpts: server.ProjectServiceOptions = {
             host: serverHost,
-            logger,
+            logger: projectSystem.nullLogger,
             cancellationToken: { isCancellationRequested: () => false },
             useSingleInferredProject: false,
             typingsInstaller: undefined
diff --git a/src/harness/unittests/session.ts b/src/harness/unittests/session.ts
index 862ebee4b03ab..1ce5792a81bec 100644
--- a/src/harness/unittests/session.ts
+++ b/src/harness/unittests/session.ts
@@ -28,18 +28,6 @@ namespace ts.server {
         createHash: Harness.LanguageService.mockHash,
     };
 
-    const mockLogger: Logger = {
-        close: noop,
-        hasLevel(): boolean { return false; },
-        loggingEnabled(): boolean { return false; },
-        perftrc: noop,
-        info: noop,
-        startGroup: noop,
-        endGroup: noop,
-        msg: noop,
-        getLogFileName: (): string => undefined
-    };
-
     class TestSession extends Session {
         getProjectService() {
             return this.projectService;
@@ -58,7 +46,7 @@ namespace ts.server {
                 typingsInstaller: undefined,
                 byteLength: Utils.byteLength,
                 hrtime: process.hrtime,
-                logger: mockLogger,
+                logger: projectSystem.nullLogger,
                 canUseEvents: true
             };
             return new TestSession(opts);
@@ -408,7 +396,7 @@ namespace ts.server {
                     typingsInstaller: undefined,
                     byteLength: Utils.byteLength,
                     hrtime: process.hrtime,
-                    logger: mockLogger,
+                    logger: projectSystem.nullLogger,
                     canUseEvents: true
                 });
                 this.addProtocolHandler(this.customHandler, () => {
@@ -475,7 +463,7 @@ namespace ts.server {
                     typingsInstaller: undefined,
                     byteLength: Utils.byteLength,
                     hrtime: process.hrtime,
-                    logger: mockLogger,
+                    logger: projectSystem.nullLogger,
                     canUseEvents: true
                 });
                 this.addProtocolHandler("echo", (req: protocol.Request) => ({
diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts
index 4a7cafa245bb9..db4f43cd1c5b6 100644
--- a/src/harness/unittests/tsserverProjectSystem.ts
+++ b/src/harness/unittests/tsserverProjectSystem.ts
@@ -34,14 +34,13 @@ namespace ts.projectSystem {
     }
 
     export const nullLogger: server.Logger = {
-        close: () => void 0,
-        hasLevel: () => void 0,
+        close: noop,
+        hasLevel: () => false,
         loggingEnabled: () => false,
-        perftrc: () => void 0,
-        info: () => void 0,
-        startGroup: () => void 0,
-        endGroup: () => void 0,
-        msg: () => void 0,
+        perftrc: noop,
+        info: noop,
+        err: noop,
+        group: noop,
         getLogFileName: (): string => undefined
     };
 
diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
index 5bb1da251eacb..554ac337920bd 100644
--- a/src/server/editorServices.ts
+++ b/src/server/editorServices.ts
@@ -928,26 +928,24 @@ namespace ts.server {
                 return;
             }
 
-            this.logger.startGroup();
+            this.logger.group(info => {
+                let counter = 0;
+                counter = printProjects(this.externalProjects, info, counter);
+                counter = printProjects(this.configuredProjects, info, counter);
+                printProjects(this.inferredProjects, info, counter);
 
-            let counter = 0;
-            counter = printProjects(this.logger, this.externalProjects, counter);
-            counter = printProjects(this.logger, this.configuredProjects, counter);
-            counter = printProjects(this.logger, this.inferredProjects, counter);
-
-            this.logger.info("Open files: ");
-            for (const rootFile of this.openFiles) {
-                this.logger.info(`\t${rootFile.fileName}`);
-            }
-
-            this.logger.endGroup();
+                info("Open files: ");
+                for (const rootFile of this.openFiles) {
+                    info(`\t${rootFile.fileName}`);
+                }
+            });
 
-            function printProjects(logger: Logger, projects: Project[], counter: number) {
+            function printProjects(projects: Project[], info: (msg: string) => void, counter: number): number {
                 for (const project of projects) {
                     project.updateGraph();
-                    logger.info(`Project '${project.getProjectName()}' (${ProjectKind[project.projectKind]}) ${counter}`);
-                    logger.info(project.filesToString());
-                    logger.info("-----------------------------------------------");
+                    info(`Project '${project.getProjectName()}' (${ProjectKind[project.projectKind]}) ${counter}`);
+                    info(project.filesToString());
+                    info("-----------------------------------------------");
                     counter++;
                 }
                 return counter;
diff --git a/src/server/server.ts b/src/server/server.ts
index 6b89019632fe9..47a858c0efd89 100644
--- a/src/server/server.ts
+++ b/src/server/server.ts
@@ -139,8 +139,6 @@ namespace ts.server {
     class Logger implements server.Logger {
         private fd = -1;
         private seq = 0;
-        private inGroup = false;
-        private firstInGroup = true;
 
         constructor(private readonly logFilename: string,
             private readonly traceToConsole: boolean,
@@ -170,22 +168,24 @@ namespace ts.server {
         }
 
         perftrc(s: string) {
-            this.msg(s, Msg.Perf);
+            this.msg(s, "Perf");
         }
 
         info(s: string) {
-            this.msg(s, Msg.Info);
+            this.msg(s, "Info");
         }
 
-        startGroup() {
-            this.inGroup = true;
-            this.firstInGroup = true;
+        err(s: string) {
+            this.msg(s, "Err");
         }
 
-        endGroup() {
-            this.inGroup = false;
+        group(logGroupEntries: (log: (msg: string) => void) => void) {
+            let firstInGroup = false;
+            logGroupEntries(s => {
+                this.msg(s, "Info", /*inGroup*/ true, firstInGroup);
+                firstInGroup = false;
+            });
             this.seq++;
-            this.firstInGroup = true;
         }
 
         loggingEnabled() {
@@ -196,26 +196,32 @@ namespace ts.server {
             return this.loggingEnabled() && this.level >= level;
         }
 
-        msg(s: string, type: Msg.Types = Msg.Err) {
-            if (this.fd >= 0 || this.traceToConsole) {
-                s = `[${nowString()}] ${s}\n`;
+        private msg(s: string, type: string, inGroup = false, firstInGroup = false) {
+            if (!this.canWrite) return;
+
+            s = `[${nowString()}] ${s}\n`;
+            if (!inGroup || firstInGroup) {
                 const prefix = Logger.padStringRight(type + " " + this.seq.toString(), "          ");
-                if (this.firstInGroup) {
-                    s = prefix + s;
-                    this.firstInGroup = false;
-                }
-                if (!this.inGroup) {
-                    this.seq++;
-                    this.firstInGroup = true;
-                }
-                if (this.fd >= 0) {
-                    const buf = new Buffer(s);
-                    // tslint:disable-next-line no-null-keyword
-                    fs.writeSync(this.fd, buf, 0, buf.length, /*position*/ null);
-                }
-                if (this.traceToConsole) {
-                    console.warn(s);
-                }
+                s = prefix + s;
+            }
+            this.write(s);
+            if (!inGroup) {
+                this.seq++;
+            }
+        }
+
+        private get canWrite() {
+            return this.fd >= 0 || this.traceToConsole;
+        }
+
+        private write(s: string) {
+            if (this.fd >= 0) {
+                const buf = new Buffer(s);
+                // tslint:disable-next-line no-null-keyword
+                fs.writeSync(this.fd, buf, 0, buf.length, /*position*/ null);
+            }
+            if (this.traceToConsole) {
+                console.warn(s);
             }
         }
     }
diff --git a/src/server/session.ts b/src/server/session.ts
index d8e0f695deff5..3c9c1b714de19 100644
--- a/src/server/session.ts
+++ b/src/server/session.ts
@@ -366,7 +366,7 @@ namespace ts.server {
                     msg += "\n" + (<StackTraceError>err).stack;
                 }
             }
-            this.logger.msg(msg, Msg.Err);
+            this.logger.err(msg);
         }
 
         public send(msg: protocol.Message) {
@@ -1946,7 +1946,7 @@ namespace ts.server {
                 return this.executeWithRequestId(request.seq, () => handler(request));
             }
             else {
-                this.logger.msg(`Unrecognized JSON command: ${JSON.stringify(request)}`, Msg.Err);
+                this.logger.err(`Unrecognized JSON command: ${JSON.stringify(request)}`);
                 this.output(undefined, CommandNames.Unknown, request.seq, `Unrecognized JSON command: ${request.command}`);
                 return { responseRequired: false };
             }
diff --git a/src/server/utilities.ts b/src/server/utilities.ts
index fc88f11408a93..40942462d1d30 100644
--- a/src/server/utilities.ts
+++ b/src/server/utilities.ts
@@ -17,22 +17,11 @@ namespace ts.server {
         loggingEnabled(): boolean;
         perftrc(s: string): void;
         info(s: string): void;
-        startGroup(): void;
-        endGroup(): void;
-        msg(s: string, type?: Msg.Types): void;
+        err(s: string): void;
+        group(logGroupEntries: (log: (msg: string) => void) => void): void;
         getLogFileName(): string;
     }
 
-    export namespace Msg {
-        export type Err = "Err";
-        export const Err: Err = "Err";
-        export type Info = "Info";
-        export const Info: Info = "Info";
-        export type Perf = "Perf";
-        export const Perf: Perf = "Perf";
-        export type Types = Err | Info | Perf;
-    }
-
     function getProjectRootPath(project: Project): Path {
         switch (project.projectKind) {
             case ProjectKind.Configured: