Snow 1634717 configuration layer (#892)

Author: sfc-gh-fpawlowski

lib/configuration/client_configuration.js

@@ -24,6 +24,7 @@ function getDefaultDirectories() {
   const directories = [];
 
   const driverDirectory = getDriverDirectory();
+  Logger.getInstance().debug(`Detected driver directory: ${driverDirectory}`);
 
   if (driverDirectory) {
     directories.push(
@@ -37,6 +38,7 @@ function getDefaultDirectories() {
   }
 
   const homedir = os.homedir();
+  Logger.getInstance().debug(`Detected home directory: ${homedir}`);
 
   if (exists(homedir)) {
     directories.push(
@@ -46,9 +48,10 @@ function getDefaultDirectories() {
       }
     );
   } else {
-    Logger.getInstance().warn('Home directory of the user is not present');
+    Logger.getInstance().warn('Home directory of the user is not defined');
   }
 
+  Logger.getInstance().debug(`Detected default directories: ${driverDirectory}`);
   return directories;
 }
 
@@ -91,6 +94,8 @@ class ConfigurationError extends Error {
 function levelFromString(value) {
   const level = value.toUpperCase();
   if (!allLevels.includes(level)) {
+
+    Logger.getInstance().error(`Tried to create unsupported log level from string: ${value}`);
     throw new Error('Unknown log level: ' + value);
   }
   return level;
@@ -110,46 +115,69 @@ function ConfigurationUtil(fsPromisesModule, processModule) {
    * @return {Promise<ClientConfig>} Client configuration.
    */
   this.getClientConfig = async function (configFilePath) {
+    Logger.getInstance().debug('Retrieving client config');
+
     const path = await findConfig(configFilePath);
     if (!exists(path) || path === '') {
+      Logger.getInstance().info('No config file path found. Client config will not be used.');
       return null;
     }
 
     const isFileOk = await isFileNotWritableByGroupOrOthers(path, fsPromises).catch(err => {
+      Logger.getInstance().warn('Failed to inspect config file path permissions. Client config will not be used.');
       throw new ConfigurationError('Finding client configuration failed', err);
     });
 
     if (!isFileOk) {
+      Logger.getInstance().warn(`Config file path permissions are invalid. File: ${path} can be modified by group or others. Client config will not be used.`);
       throw new ConfigurationError(`Configuration file: ${path} can be modified by group or others`, 'IncorrectPerms');
     }
+    Logger.getInstance().debug(`Config file path permissions are valid. Path: ${path}`);
 
     const configFileContents = await readFileConfig(path);
+    Logger.getInstance().info('Using client configuration from path: %s', path);
+
     return configFileContents == null ? null : parseConfigFile(path, configFileContents);
   };
 
   function readFileConfig(filePath) {
+    Logger.getInstance().debug(`Reading config file. Path: ${filePath}`);
+
     if (!filePath) {
+      Logger.getInstance().trace(`Path of config file is not specified. Nothing to read. Path: ${filePath}`);
       return Promise.resolve(null);
     }
     return fsPromises.readFile(filePath, { encoding: 'utf8' })
       .catch(err => {
+        Logger.getInstance().debug(`Reading configuration from the file failed. Path: ${filePath}`);
         throw new ConfigurationError('Finding client configuration failed', err);
       });
   }
 
   function parseConfigFile(path, configurationJson) {
+    Logger.getInstance().debug('Parsing config file: %s', path);
     try {
       const parsedConfiguration = JSON.parse(configurationJson);
+      Logger.getInstance().trace('Config file contains correct JSON structure. Validating the input.');
+
       checkUnknownEntries(parsedConfiguration);
       validate(parsedConfiguration);
-      return new ClientConfig(
+
+      Logger.getInstance().debug('Config file contains valid configuration input.');
+
+      const clientConfig = new ClientConfig(
         path,
         new ClientLoggingConfig(
           getLogLevel(parsedConfiguration),
           getLogPath(parsedConfiguration)
         )
       );
+
+      Logger.getInstance().info('Client Configuration created with Log Level: %s and Log Path: %s', clientConfig.loggingConfig.logLevel, clientConfig.loggingConfig.logPath);
+      return clientConfig;
+
     } catch (err) {
+      Logger.getInstance().error('Parsing client configuration failed. Used config file from path: %s', path);
       throw new ConfigurationError('Parsing client configuration failed', err);
     }
   }
@@ -170,21 +198,27 @@ function ConfigurationUtil(fsPromisesModule, processModule) {
   function validateLogLevel(configuration) {
     const logLevel = getLogLevel(configuration);
     if (logLevel == null) {
+      Logger.getInstance().debug('Log level is not specified.');
       return;
     }
     if (!isString(logLevel)) {
-      throw new Error('Log level is not a string');
+      const errorMessage = 'Log level is not a string.';
+      Logger.getInstance().error(errorMessage);
+      throw new Error(errorMessage);
     }
     levelFromString(logLevel);
   }
 
   function validateLogPath(configuration) {
     const logPath = getLogPath(configuration);
     if (logPath == null) {
+      Logger.getInstance().debug('Log path is not specified');
       return;
     }
     if (!isString(logPath)) {
-      throw new Error('Log path is not a string');
+      const errorMessage = 'Log path is not a string.';
+      Logger.getInstance().error(errorMessage);
+      throw new Error(errorMessage);
     }
   }
 
@@ -197,21 +231,22 @@ function ConfigurationUtil(fsPromisesModule, processModule) {
   }
 
   async function findConfig(filePathFromConnectionString) {
+    Logger.getInstance().trace(`findConfig() called with param: ${filePathFromConnectionString}`);
     if (exists(filePathFromConnectionString)) {
-      Logger.getInstance().info('Using client configuration path from a connection string: %s', filePathFromConnectionString);
+      Logger.getInstance().info('Found client configuration path in a connection string. Path: %s', filePathFromConnectionString);
       return filePathFromConnectionString;
     }
     const filePathFromEnvVariable = await getFilePathFromEnvironmentVariable();
     if (exists(filePathFromEnvVariable)) {
-      Logger.getInstance().info('Using client configuration path from an environment variable: %s', filePathFromEnvVariable);
+      Logger.getInstance().info('Found client configuration path in an environment variable. Path: %s', filePathFromEnvVariable);
       return filePathFromEnvVariable;
     }
     const fileFromDefDirs = await searchForConfigInDefaultDirectories();
     if (exists(fileFromDefDirs)) {
-      Logger.getInstance().info('Using client configuration path from %s directory: %s', fileFromDefDirs.dirDescription, fileFromDefDirs.configPath);
+      Logger.getInstance().info('Found client configuration path in %s directory. Path: %s', fileFromDefDirs.dirDescription, fileFromDefDirs.configPath);
       return fileFromDefDirs.configPath;
     }
-    Logger.getInstance().info('No client config file found in default directories');
+    Logger.getInstance().info('No client config detected.');
     return null;
   }
 
@@ -224,12 +259,15 @@ function ConfigurationUtil(fsPromisesModule, processModule) {
   }
 
   async function searchForConfigInDefaultDirectories() {
+    Logger.getInstance().debug(`Searching for config in default directories: ${defaultDirectories}`);
     for (const directory of defaultDirectories) {
       const configPath = await searchForConfigInDictionary(directory.dir, directory.dirDescription);
       if (exists(configPath)) {
+        Logger.getInstance().debug(`Config found in the default directory: ${directory.dir}. Path: ${configPath}`);
         return { configPath: configPath, dirDescription: directory.dirDescription };
       }
     }
+    Logger.getInstance().debug('Unable to find config in any default directory.');
     return null;
   }
 

lib/configuration/connection_configuration.js

@@ -32,35 +32,45 @@ function readTokenFromFile(fixedConfiguration) {
   validateOnlyUserReadWritePermission(resolvedPath);
   fixedConfiguration.token = fs.readFileSync(resolvedPath, 'utf-8').trim();
   if (!fixedConfiguration.token) {
+    Logger.getInstance().error('The token does not exist or has empty value.');
     throw new Error('The token does not exist or has empty value');
   }
   const tokenChecksum = generateChecksum(fixedConfiguration.token);
   Logger.getInstance().info('Token used in connection has been read from file: %s. Checksum: %s', resolvedPath, tokenChecksum);
 }
 
 function loadConnectionConfiguration() {
+  Logger.getInstance().trace('Loading connection configuration from the local files...');
   const snowflakeConfigDir = defaultIfNotSet(process.env.SNOWFLAKE_HOME, path.join(os.homedir(), '.snowflake'));
+  Logger.getInstance().trace('Looking for connection file in directory %s', snowflakeConfigDir);
   const filePath = path.join(snowflakeConfigDir, 'connections.toml');
   const resolvedPath = fs.realpathSync(filePath);
+  Logger.getInstance().trace('Connection configuration file found under the path %s. Validating file access.', resolvedPath);
+
   validateOnlyUserReadWritePermission(resolvedPath);
   const str = fs.readFileSync(resolvedPath, { encoding: 'utf8' });
   const configurationChecksum = generateChecksum(str);
-  Logger.getInstance().info('Connection configuration file is read from file: %s. Checksum: %s', resolvedPath, configurationChecksum);
+  Logger.getInstance().info('Connection configuration file is read from path: %s. Checksum: %s', resolvedPath, configurationChecksum);
+  Logger.getInstance().trace('Trying to parse the config file');
   const parsingResult = toml.parse(str);
+
   const configurationName = defaultIfNotSet(process.env.SNOWFLAKE_DEFAULT_CONNECTION_NAME, 'default');
 
   if (parsingResult[configurationName] !== undefined) {
     const fixedConfiguration = fixUserKey(parsingResult[configurationName]);
     if (shouldReadTokenFromFile(fixedConfiguration)) {
+      Logger.getInstance().info('Trying to read token from config file.');
       readTokenFromFile(fixedConfiguration);
     }
     return fixedConfiguration;
   } else {
+    Logger.getInstance().error('Connection configuration with name %s does not exist in the file %s', configurationName, resolvedPath);
     throw new Error(`Connection configuration with name ${configurationName} does not exist`);
   }
 }
 
 function fixUserKey(parsingResult) {
+  Logger.getInstance().trace('Empty Username field will be filled with \'User\' field value.');
   if (parsingResult['username'] === undefined && parsingResult['user'] !== undefined){
     parsingResult['username'] = parsingResult['user'];
   }