Add Debug class for errors (#1429)

* Add debug logging utils for language server and vs code
* Add stack traces to debug errors
* moved config loader to use debug util

Author: JakeDawkins

CHANGELOG.md

@@ -19,11 +19,11 @@
 - `apollo-graphql`
   - <First `apollo-graphql` related entry goes here>
 - `apollo-language-server`
-  - <First `apollo-language-server` related entry goes here>
+  - Add debugging util classes for better error/warning handling [#1429](https://github.com/apollographql/apollo-tooling/pull/1429)
 - `apollo-tools`
   - <First `apollo-tools` related entry goes here>
 - `vscode-apollo`
-  - <First `vscode-apollo` related entry goes here>
+  - Add debugging util class for better logging in vs code [#1429](https://github.com/apollographql/apollo-tooling/pull/1429)
 
 ## `apollo-language-server@1.14.3`
 

packages/apollo-language-server/src/config/__tests__/loadConfig.ts

@@ -153,8 +153,14 @@ describe("loadConfig", () => {
       writeFilesToDir(dir, {
         "package.json": `{"apollo":{"client": {"service": "hello"}} }`
       });
+
+      // silence the warning
+      const spy = jest.spyOn(console, "warn");
+      spy.mockImplementationOnce(() => {});
+
       const config = await loadConfig({ configPath: dirPath });
 
+      spy.mockRestore();
       expect(config.client.service).toEqual("hello");
     });
 
@@ -169,34 +175,47 @@ describe("loadConfig", () => {
   });
 
   describe("errors", () => {
-    it("throws when config file is empty", done => {
+    it("throws when config file is empty", async () => {
       writeFilesToDir(dir, { "my.config.js": `` });
 
-      return loadConfig({
+      const spy = jest.spyOn(console, "error");
+      // use this to keep the log quiet
+      spy.mockImplementation();
+
+      await loadConfig({
         configPath: dirPath,
         configFileName: "my.config.js"
-      }).catch(err => {
-        expect(err.message).toMatch(/.*A config file failed to load at.*/);
-        done();
       });
+
+      expect(spy).toHaveBeenCalledWith(
+        expect.stringMatching(/config file failed to load/i)
+      );
+
+      spy.mockRestore();
     });
 
-    it("throws when explorer.search fails", done => {
+    it("throws when explorer.search fails", async () => {
       writeFilesToDir(dir, { "my.config.js": `* 98375^%*&^ its lit` });
 
-      return loadConfig({
+      const spy = jest.spyOn(console, "error");
+      // use this to keep the log quiet
+      spy.mockImplementation();
+
+      await loadConfig({
         configPath: dirPath,
         configFileName: "my.config.js"
-      }).catch(err => {
-        expect(err.message).toMatch(
-          /.*A config file failed to load with options.*/
-        );
-        done();
       });
+
+      expect(spy).toHaveBeenCalledWith(
+        expect.stringMatching(/config file failed to load/i)
+      );
+
+      spy.mockRestore();
     });
 
     it("issues a deprecation warning when loading config from package.json", async () => {
-      jest.spyOn(global.console, "warn");
+      const spy = jest.spyOn(console, "warn");
+      spy.mockImplementation();
 
       writeFilesToDir(dir, {
         "package.json": `{"apollo":{"client": {"service": "hello"}} }`
@@ -207,37 +226,47 @@ describe("loadConfig", () => {
         configFileName: "package.json"
       });
 
-      expect(console.warn.mock.calls[0][0]).toMatchInlineSnapshot(
-        `"The \\"apollo\\" package.json configuration key will no longer be supported in Apollo v3. Please use the apollo.config.js file for Apollo project configuration. For more information, see: https://bit.ly/2ByILPj"`
+      expect(spy).toHaveBeenCalledWith(
+        expect.stringMatching(/The "apollo" package.json configuration/i)
       );
+
+      spy.mockRestore();
     });
 
-    it("throws if a config file was expected but not found", done => {
+    it("throws if a config file was expected but not found", async () => {
+      const spy = jest.spyOn(console, "error");
+      spy.mockImplementation();
+
       writeFilesToDir(dir, { "my.config.js": `module.exports = {}` });
 
-      return loadConfig({
+      await loadConfig({
         configFileName: "my.TYPO.js",
         requireConfig: true // this is what we're testing
-      }).catch(err => {
-        expect(err.message).toMatch(/.*No Apollo config found for project*/);
-        done();
       });
+
+      expect(spy).toHaveBeenCalledWith(
+        expect.stringMatching(/no apollo config/i)
+      );
+      spy.mockRestore();
     });
 
-    it("throws if project type cant be resolved", () => {
+    it("throws if project type cant be resolved", async () => {
+      const spy = jest.spyOn(console, "error");
+      spy.mockImplementation();
+
       writeFilesToDir(dir, {
         "my.config.js": `module.exports = {}`
       });
 
-      const load = async () =>
-        await loadConfig({
-          configPath: dirPath,
-          configFileName: "my.config.js"
-        });
+      await loadConfig({
+        configPath: dirPath,
+        configFileName: "my.config.js"
+      });
 
-      return expect(load()).rejects.toMatchInlineSnapshot(
-        `[Error: Unable to resolve project type. Please add either a client or service config. For more information, please refer to https://bit.ly/2ByILPj]`
+      expect(spy).toHaveBeenCalledWith(
+        expect.stringMatching(/unable to resolve/i)
       );
+      spy.mockRestore();
     });
   });
 
@@ -313,20 +342,6 @@ describe("loadConfig", () => {
 
       expect(config.isService).toEqual(true);
     });
-
-    it("throws if project type cant be inferred", done => {
-      writeFilesToDir(dir, {
-        "my.config.js": `module.exports = { engine: { endpoint: 'http://a.a' } }`
-      });
-
-      return loadConfig({
-        configPath: dirPath,
-        configFileName: "my.config.js"
-      }).catch(err => {
-        expect(err.message).toMatch(/.*Unable to resolve project type.*/);
-        done();
-      });
-    });
   });
 
   describe("service name", () => {

packages/apollo-language-server/src/config/loadConfig.ts

@@ -14,6 +14,7 @@ import {
 } from "./config";
 import { getServiceFromKey } from "./utils";
 import URI from "vscode-uri";
+import { Debug } from "../utilities";
 
 // config settings
 const MODULE_NAME = "apollo";
@@ -80,28 +81,26 @@ export async function loadConfig({
       ApolloConfigFormat
     >;
   } catch (error) {
-    throw new Error(
-      `A config file failed to load with options: ${JSON.stringify(
-        arguments[0]
-      )}.
-      The error was: ${error}`
-    );
+    return Debug.error(`A config file failed to load with options: ${JSON.stringify(
+      arguments[0]
+    )}.
+    The error was: ${error}`);
   }
 
   if (configPath && !loadedConfig) {
-    throw new Error(
+    return Debug.error(
       `A config file failed to load at '${configPath}'. This is likely because this file is empty or malformed. For more information, please refer to: https://bit.ly/2ByILPj`
     );
   }
 
   if (loadedConfig && loadedConfig.filepath.endsWith("package.json")) {
-    console.warn(
+    Debug.warning(
       'The "apollo" package.json configuration key will no longer be supported in Apollo v3. Please use the apollo.config.js file for Apollo project configuration. For more information, see: https://bit.ly/2ByILPj'
     );
   }
 
   if (requireConfig && !loadedConfig) {
-    throw new Error(
+    return Debug.error(
       `No Apollo config found for project. For more information, please refer to:
       https://bit.ly/2ByILPj`
     );
@@ -135,7 +134,7 @@ export async function loadConfig({
   else if (loadedConfig && loadedConfig.config.client) projectType = "client";
   else if (loadedConfig && loadedConfig.config.service) projectType = "service";
   else
-    throw new Error(
+    return Debug.error(
       "Unable to resolve project type. Please add either a client or service config. For more information, please refer to https://bit.ly/2ByILPj"
     );
 

packages/apollo-language-server/src/index.ts

@@ -24,3 +24,6 @@ export * from "./config";
 // Generated types
 import * as graphqlTypes from "./graphqlTypes";
 export { graphqlTypes };
+
+// debug logger
+export { Debug } from "./utilities";

packages/apollo-language-server/src/server.ts

@@ -12,9 +12,10 @@ import { QuickPickItem } from "vscode";
 import { GraphQLWorkspace } from "./workspace";
 import { GraphQLLanguageProvider } from "./languageProvider";
 import { LanguageServerLoadingHandler } from "./loadingHandler";
-import { debounceHandler } from "./utilities";
+import { debounceHandler, Debug } from "./utilities";
 
 const connection = createConnection(ProposedFeatures.all);
+Debug.SetConnection(connection);
 
 let hasWorkspaceFolderCapability = false;
 

packages/apollo-language-server/src/utilities/debug.ts

@@ -0,0 +1,92 @@
+import { IConnection } from "vscode-languageserver";
+
+/**
+ * for errors (and other logs in debug mode) we want to print
+ * a stack trace showing where they were thrown. This uses an
+ * Error's stack trace, removes the three frames regarding
+ * this file (since they're useless) and returns the rest of the trace.
+ */
+const createAndTrimStackTrace = () => {
+  let stack: string | undefined = new Error().stack;
+  // remove the lines in the stack from _this_ function and the caller (in this file) and shorten the trace
+  return stack && stack.split("\n").length > 2
+    ? stack
+        .split("\n")
+        .slice(3, 7)
+        .join("\n")
+    : stack;
+};
+
+type Logger = (message?: any) => void;
+
+export class Debug {
+  private static connection?: IConnection;
+  private static infoLogger: Logger = message =>
+    console.log("[INFO] " + message);
+  private static warningLogger: Logger = message =>
+    console.warn("[WARNING] " + message);
+  private static errorLogger: Logger = message =>
+    console.error("[ERROR] " + message);
+
+  /**
+   * Setting a connection overrides the default info/warning/error
+   * loggers to pass a notification to the connection
+   */
+  public static SetConnection(conn: IConnection) {
+    Debug.connection = conn;
+    Debug.infoLogger = message =>
+      Debug.connection!.sendNotification("serverDebugMessage", {
+        type: "info",
+        message: message
+      });
+    Debug.warningLogger = message =>
+      Debug.connection!.sendNotification("serverDebugMessage", {
+        type: "warning",
+        message: message
+      });
+    Debug.errorLogger = message =>
+      Debug.connection!.sendNotification("serverDebugMessage", {
+        type: "error",
+        message: message
+      });
+  }
+
+  /**
+   * Allow callers to set their own error logging utils.
+   * These will default to console.log/warn/error
+   */
+  public static SetLoggers({
+    info,
+    warning,
+    error
+  }: {
+    info?: Logger;
+    warning?: Logger;
+    error?: Logger;
+  }) {
+    if (info) Debug.infoLogger = info;
+    if (warning) Debug.warningLogger = warning;
+    if (error) Debug.errorLogger = error;
+  }
+
+  public static info(message: string) {
+    Debug.infoLogger(message);
+  }
+
+  public static error(message: string) {
+    const stack = createAndTrimStackTrace();
+    Debug.errorLogger(`${message}\n${stack}`);
+  }
+
+  public static warning(message: string) {
+    Debug.warningLogger(message);
+  }
+
+  public static sendErrorTelemetry(message: string) {
+    Debug.connection &&
+      Debug.connection.sendNotification("serverDebugMessage", {
+        type: "errorTelemetry",
+        message: message
+      });
+  }
+}

packages/apollo-language-server/src/utilities/index.ts

@@ -1,2 +1,3 @@
 export * from "./debouncer";
 export * from "./uri";
+export { Debug } from "./debug";

packages/apollo-language-server/src/workspace.ts

@@ -18,6 +18,7 @@ import { ServiceID, SchemaTag, ClientIdentity } from "./engine";
 import { GraphQLClientProject, isClientProject } from "./project/client";
 import { GraphQLServiceProject } from "./project/service";
 import URI from "vscode-uri";
+import { Debug } from "./utilities";
 
 export interface WorkspaceConfig {
   clientIdentity?: ClientIdentity;
@@ -123,20 +124,26 @@ export class GraphQLWorkspace {
     const projectConfigs = Array.from(apolloConfigFolders).map(configFolder =>
       loadConfig({ configPath: configFolder, requireConfig: true })
         .then(config => {
-          foundConfigs.push(config);
-          const projectsForConfig = config.projects.map(projectConfig =>
-            this.createProject({ config, folder })
-          );
-
-          const existingProjects =
-            this.projectsByFolderUri.get(folder.uri) || [];
-
-          this.projectsByFolderUri.set(folder.uri, [
-            ...existingProjects,
-            ...projectsForConfig
-          ]);
+          if (config) {
+            foundConfigs.push(config);
+            const projectsForConfig = config.projects.map(projectConfig =>
+              this.createProject({ config, folder })
+            );
+
+            const existingProjects =
+              this.projectsByFolderUri.get(folder.uri) || [];
+
+            this.projectsByFolderUri.set(folder.uri, [
+              ...existingProjects,
+              ...projectsForConfig
+            ]);
+          } else {
+            Debug.error(
+              `Workspace failed to load config from: ${configFolder}/`
+            );
+          }
         })
-        .catch(error => console.error(error))
+        .catch(error => Debug.error(error))
     );
 
     await Promise.all(projectConfigs);