[DECO-333] Assume you have all the permissions if can't access workspace confs (#232)

Right now we just log the error and let users continue using the
extension.

Author: kartikgupta-db

packages/databricks-sdk-js/src/context/Context.ts

@@ -6,40 +6,51 @@ export interface ContextItems {
     logger?: NamedLogger;
     opId?: string;
     opName?: string;
+    rootClassName?: string;
+    rootFnName?: string;
     cancellationToken?: CancellationToken;
 }
 
 export class Context {
-    private _logger?: NamedLogger;
+    private _items: ContextItems = {};
+
     get logger() {
-        return this._logger;
+        return this._items.logger;
     }
 
-    private _opId: string;
     get opId() {
-        return this._opId;
+        return this._items.opId;
     }
 
-    private _opName?: string;
     get opName() {
-        return this._opName;
+        return this._items.opName;
+    }
+
+    get rootClassName() {
+        return this._items.rootClassName;
+    }
+
+    get rootFnName() {
+        return this._items.rootFnName;
     }
 
-    private _cancelationToken?: CancellationToken;
     get cancellationToken() {
-        return this._cancelationToken;
+        return this._items?.cancellationToken;
     }
 
     constructor(items: ContextItems = {}) {
-        this._opId = randomUUID();
         this.setItems(items);
+        this._items.opId = this._items.opId ?? randomUUID();
     }
 
     setItems(items: ContextItems = {}) {
-        this._cancelationToken =
-            items.cancellationToken ?? this._cancelationToken;
-        this._opId = items.opId ?? this._opId;
-        this._opName = items.opName ?? this._opName;
-        this._logger = items.logger ?? this._logger;
+        this._items = {
+            ...this._items,
+            ...items,
+        };
+    }
+
+    copy() {
+        return new Context(this._items);
     }
 }

packages/databricks-sdk-js/src/logging/NamedLogger.ts

@@ -48,7 +48,14 @@ export class NamedLogger {
         return this._context?.opId;
     }
     get opName() {
-        return this._context?.opName;
+        const rootNames = [
+            this._context?.rootClassName,
+            this._context?.rootFnName,
+        ].filter((e) => e !== undefined);
+
+        return this._context?.opName ?? rootNames.length !== 0
+            ? rootNames.join(".")
+            : undefined;
     }
 
     get loggingFnName() {
@@ -114,17 +121,15 @@ export class NamedLogger {
         this.log(LEVELS.error, message, {error: obj});
     }
 
-    withContext<T>({
+    withContext({
         context,
         loggingFnName,
-        fn,
     }: {
         context: Context;
         loggingFnName: string;
-        fn: () => T;
     }) {
         this._context = context;
         this._loggingFnName = loggingFnName;
-        return fn();
+        return this;
     }
 }

packages/databricks-sdk-js/src/logging/loggingDecorators.ts

@@ -2,7 +2,7 @@ import "..";
 import {NamedLogger} from "./NamedLogger";
 import {getContextParamIndex, Context, ContextItems} from "../context";
 
-export function withLogContext(name: string) {
+export function withLogContext(name: string, opName?: string) {
     return function (
         _target: any,
         _propertyKey: string,
@@ -17,23 +17,28 @@ export function withLogContext(name: string) {
             while (args.length <= contextParamIndex) {
                 args.push(undefined);
             }
-            const contextParam =
+            const contextParam = (
                 (args[contextParamIndex] as Context | undefined) ??
-                new Context();
+                new Context()
+            ).copy();
 
-            const items: ContextItems = {logger};
-            if (contextParam.opName === undefined) {
-                items.opName = `${this.constructor.name}.${_propertyKey}`;
-            }
+            const items: ContextItems = {
+                logger,
+                opName: contextParam.opName ?? opName,
+                rootClassName:
+                    contextParam.rootClassName ?? this.constructor.name,
+                rootFnName: contextParam.rootFnName ?? _propertyKey,
+            };
             contextParam.setItems(items);
 
             args[contextParamIndex] = contextParam;
 
-            return logger.withContext({
+            logger.withContext({
                 context: contextParam,
                 loggingFnName: `${this.constructor.name}.${_propertyKey}`,
-                fn: () => method.apply(this, args),
             });
+
+            return method.apply(this, args);
         };
     };
 }

packages/databricks-sdk-js/src/services/WorkspaceConf.ts

@@ -1,5 +1,6 @@
-import {ApiClient, CancellationToken, WorkspaceConfService} from "..";
-import {Context} from "../context";
+import {ApiClient, WorkspaceConfService} from "..";
+import {context, Context} from "../context";
+import {ExposedLoggers, withLogContext} from "../logging";
 
 type StringBool = "true" | "false" | "";
 
@@ -40,27 +41,26 @@ export interface WorkspaceConfProps {
 export class WorkspaceConf {
     constructor(private readonly client: ApiClient) {}
 
+    @withLogContext(ExposedLoggers.SDK)
     async getStatus(
         keys: Array<keyof WorkspaceConfProps>,
-        cancellationToken?: CancellationToken
+        @context ctx?: Context
     ): Promise<Partial<WorkspaceConfProps>> {
         const wsConfApi = new WorkspaceConfService(this.client);
         return await wsConfApi.getStatus(
             {
                 keys: keys.join(","),
             },
-            new Context({cancellationToken})
+            ctx
         );
     }
 
+    @withLogContext(ExposedLoggers.SDK)
     async setStatus(
         request: Partial<WorkspaceConfProps>,
-        cancellationToken?: CancellationToken
+        @context ctx?: Context
     ): Promise<Partial<WorkspaceConfProps>> {
         const wsConfApi = new WorkspaceConfService(this.client);
-        return await wsConfApi.setStatus(
-            request,
-            new Context({cancellationToken})
-        );
+        return await wsConfApi.setStatus(request, ctx);
     }
 }

packages/databricks-vscode/src/configuration/DatabricksWorkspace.ts

@@ -6,7 +6,10 @@ import {
     WorkspaceConf,
     WorkspaceConfProps,
 } from "@databricks/databricks-sdk";
-import {Uri} from "vscode";
+import {Context, context} from "@databricks/databricks-sdk/dist/context";
+import {withLogContext} from "@databricks/databricks-sdk/dist/logging";
+import {Uri, window} from "vscode";
+import {Loggers} from "../logger";
 
 export class DatabricksWorkspace {
     constructor(
@@ -63,18 +66,37 @@ export class DatabricksWorkspace {
         }
     }
 
-    static async load(client: ApiClient, profile: string) {
+    @withLogContext(Loggers.Extension, "DatabricksWorkspace.load")
+    static async load(
+        client: ApiClient,
+        profile: string,
+        @context ctx?: Context
+    ) {
         const host = Uri.parse((await client.host).toString());
 
         const scimApi = new CurrentUserService(client);
-        const me = await scimApi.me();
+        const me = await scimApi.me(ctx);
 
         const wsConfApi = new WorkspaceConf(client);
-        const state = await wsConfApi.getStatus([
-            "enableProjectTypeInWorkspace",
-            "enableWorkspaceFilesystem",
-        ]);
+        let state: WorkspaceConfProps = {
+            enableProjectTypeInWorkspace: "true",
+            enableWorkspaceFilesystem: "true",
+        };
+        try {
+            state = {
+                ...state,
+                ...(await wsConfApi.getStatus(
+                    [
+                        "enableProjectTypeInWorkspace",
+                        "enableWorkspaceFilesystem",
+                    ],
+                    ctx
+                )),
+            };
+        } catch (e) {
+            ctx?.logger?.error("Can't fetch workspace confs", e);
+        }
 
-        return new DatabricksWorkspace(host, me, state as any, profile);
+        return new DatabricksWorkspace(host, me, state, profile);
     }
 }

packages/databricks-vscode/src/logger/outputConsoleTransport.ts

@@ -66,14 +66,24 @@ export function getOutputConsoleTransport(outputChannel: OutputChannel) {
 
             info[MESSAGE] =
                 info.level === "error"
-                    ? inspect(stripped, false, 1000)
+                    ? inspect(
+                          {
+                              ...stripped,
+                              level: info.level,
+                              message: info.message,
+                          },
+                          false,
+                          1000
+                      )
                     : inspect(
                           {
                               ...recursiveTruncate(
                                   stripped,
                                   workspaceConfigs.truncationDepth
                               ),
                               timestamp: new Date().toLocaleString(),
+                              level: info.level,
+                              message: info.message,
                           },
                           false,
                           workspaceConfigs.truncationDepth

packages/databricks-vscode/tsconfig.json

@@ -9,7 +9,8 @@
         "sourceMap": true,
         "rootDir": "src",
         "strict": true /* enable all strict type-checking options */,
-        "forceConsistentCasingInFileNames": true
+        "forceConsistentCasingInFileNames": true,
+        "experimentalDecorators": true
     },
     "include": ["src"]
 }