SNOW-957747: Easy logging improvements

src/main/java/net/snowflake/client/config/SFClientConfig.java

@@ -1,7 +1,10 @@
 package net.snowflake.client.config;
 
+import com.fasterxml.jackson.annotation.JsonAnySetter;
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.JsonProperty;
+import java.util.LinkedHashMap;
+import java.util.Map;
 import java.util.Objects;
 
 /** POJO class for Snowflake's client config. */
@@ -57,6 +60,8 @@ public static class CommonProps {
     @JsonProperty("log_path")
     private String logPath;
 
+    @JsonAnySetter private Map<String, Object> unknownKeys = new LinkedHashMap<>();
+
     public CommonProps() {}
 
     public void CommonProps(String logLevel, String logPath) {
@@ -80,6 +85,10 @@ public void setLogPath(String logPath) {
       this.logPath = logPath;
     }
 
+    Map<String, Object> getUnknownKeys() {
+      return unknownKeys;
+    }
+
     @Override
     public boolean equals(Object o) {
       if (this == o) {

src/main/java/net/snowflake/client/config/SFClientConfigParser.java

@@ -8,8 +8,12 @@
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Paths;
+import java.nio.file.attribute.PosixFilePermission;
+import java.util.Map;
+import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import net.snowflake.client.core.Constants;
 import net.snowflake.client.jdbc.SnowflakeDriver;
 import net.snowflake.client.log.SFLogger;
 import net.snowflake.client.log.SFLoggerFactory;
@@ -25,41 +29,77 @@ public class SFClientConfigParser {
    * connection property. 2. Environment variable: SF_CLIENT_CONFIG_FILE containing full path to
    * sf_client_config file. 3. Searches for default config file name(sf_client_config.json under the
    * driver directory from where the driver gets loaded. 4. Searches for default config file
-   * name(sf_client_config.json) under user home directory 5. Searches for default config file
-   * name(sf_client_config.json) under tmp directory.
+   * name(sf_client_config.json) under user home directory.
    *
    * @param configFilePath SF_CLIENT_CONFIG_FILE parameter read from connection URL or connection
    *     properties
    * @return SFClientConfig
    */
   public static SFClientConfig loadSFClientConfig(String configFilePath) throws IOException {
+    if (configFilePath != null) {
+      logger.info("Attempting to enable easy logging with file path {}", configFilePath);
+    }
     String derivedConfigFilePath = null;
     if (configFilePath != null && !configFilePath.isEmpty()) {
       // 1. Try to read the file at  configFilePath.
       derivedConfigFilePath = configFilePath;
+      logger.info(
+          "Using client configuration path from a connection string: {}", derivedConfigFilePath);
     } else if (System.getenv().containsKey(SF_CLIENT_CONFIG_ENV_NAME)) {
       // 2. If SF_CLIENT_CONFIG_ENV_NAME is set, read from env.
       derivedConfigFilePath = systemGetEnv(SF_CLIENT_CONFIG_ENV_NAME);
+      logger.info(
+          "Using client configuration path from an environment variable: {}",
+          derivedConfigFilePath);
     } else {
       // 3. Read SF_CLIENT_CONFIG_FILE_NAME from where jdbc jar is loaded.
       String driverLocation =
           Paths.get(getConfigFilePathFromJDBCJarLocation(), SF_CLIENT_CONFIG_FILE_NAME).toString();
       if (Files.exists(Paths.get(driverLocation))) {
         derivedConfigFilePath = driverLocation;
+        logger.info(
+            "Using client configuration path from jar directory: {}", derivedConfigFilePath);
       } else {
         // 4. Read SF_CLIENT_CONFIG_FILE_NAME if it is present in user home directory.
-        String userHomeFilePath =
-            Paths.get(systemGetProperty("user.home"), SF_CLIENT_CONFIG_FILE_NAME).toString();
-        if (Files.exists(Paths.get(userHomeFilePath))) {
-          derivedConfigFilePath = userHomeFilePath;
+        String homePath = systemGetProperty("user.home");
+        if (homePath != null) {
+          String userHomeFilePath = Paths.get(homePath, SF_CLIENT_CONFIG_FILE_NAME).toString();
+          if (Files.exists(Paths.get(userHomeFilePath))) {
+            derivedConfigFilePath = userHomeFilePath;
+            logger.info(
+                "Using client configuration path from home directory: {}", derivedConfigFilePath);
+          }
         }
       }
     }
     if (derivedConfigFilePath != null) {
       try {
+        if (Constants.getOS() != Constants.OS.WINDOWS) {
+          // Check permissions of config file
+          Set<PosixFilePermission> folderPermissions =
+              Files.getPosixFilePermissions(Paths.get(derivedConfigFilePath));
+          if (folderPermissions.contains(PosixFilePermission.GROUP_WRITE)
+              || folderPermissions.contains(PosixFilePermission.OTHERS_WRITE)) {
+            String error =
+                String.format(
+                    "Error due to other users having permission to modify the config file: %s",
+                    derivedConfigFilePath);
+            throw new IOException(error);
+          }
+        }
         File configFile = new File(derivedConfigFilePath);
         ObjectMapper objectMapper = new ObjectMapper();
         SFClientConfig clientConfig = objectMapper.readValue(configFile, SFClientConfig.class);
+        logger.info(
+            "Reading values logLevel {} and logPath {} from client configuration",
+            clientConfig.getCommonProps().getLogLevel(),
+            clientConfig.getCommonProps().getLogPath());
+
+        for (Map.Entry<String, Object> prop :
+            clientConfig.getCommonProps().getUnknownKeys().entrySet()) {
+          logger.info(
+              "Unknown configuration entry: {} with value: {}", prop.getKey(), prop.getValue());
+        }
         clientConfig.setConfigFilePath(derivedConfigFilePath);
 
         return clientConfig;

src/main/java/net/snowflake/client/jdbc/DefaultSFConnectionHandler.java

@@ -8,15 +8,19 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.nio.file.attribute.PosixFilePermission;
+import java.nio.file.attribute.PosixFilePermissions;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.SQLNonTransientConnectionException;
 import java.sql.Statement;
 import java.util.Map;
 import java.util.Properties;
+import java.util.Set;
 import java.util.logging.Level;
 import net.snowflake.client.config.SFClientConfig;
 import net.snowflake.client.config.SFClientConfigParser;
+import net.snowflake.client.core.Constants;
 import net.snowflake.client.core.SFBaseResultSet;
 import net.snowflake.client.core.SFBaseSession;
 import net.snowflake.client.core.SFBaseStatement;
@@ -136,13 +140,16 @@ private void setClientConfig() throws SnowflakeSQLLoggedException {
     String clientConfigFilePath =
         (String) connectionPropertiesMap.getOrDefault(SFSessionProperty.CLIENT_CONFIG_FILE, null);
 
-    SFClientConfig sfClientConfig;
-    try {
-      sfClientConfig = SFClientConfigParser.loadSFClientConfig(clientConfigFilePath);
-    } catch (IOException e) {
-      throw new SnowflakeSQLLoggedException(sfSession, ErrorCode.INTERNAL_ERROR, e.getMessage());
+    SFClientConfig sfClientConfig = sfSession.getSfClientConfig();
+    if (sfClientConfig == null) {
+      try {
+        sfClientConfig = SFClientConfigParser.loadSFClientConfig(clientConfigFilePath);
+      } catch (IOException e) {
+        throw new SnowflakeSQLLoggedException(
+            sfSession, ErrorCode.INTERNAL_ERROR, e.getMessage(), e.getCause());
+      }
+      sfSession.setSfClientConfig(sfClientConfig);
     }
-    sfSession.setSfClientConfig(sfClientConfig);
   }
 
   /**
@@ -181,20 +188,18 @@ && systemGetProperty("java.util.logging.config.file") == null) {
 
       if (logLevel != null && logPattern != null) {
         try {
+          logger.info("Setting logger with log level {} and log pattern {}", logLevel, logPattern);
           JDK14Logger.instantiateLogger(logLevel, logPattern);
         } catch (IOException ex) {
           throw new SnowflakeSQLLoggedException(
               sfSession, ErrorCode.INTERNAL_ERROR, ex.getMessage());
         }
         if (sfClientConfig != null) {
           logger.debug(
-              String.format(
-                  "SF Client config found at location: %s.", sfClientConfig.getConfigFilePath()));
+              "SF Client config found at location: {}.", sfClientConfig.getConfigFilePath());
         }
         logger.debug(
-            String.format(
-                "Instantiating JDK14Logger with level: %s , output path: %s",
-                logLevel, logPattern));
+            "Instantiating JDK14Logger with level: {}, output path: {}", logLevel, logPattern);
       }
     }
   }
@@ -206,11 +211,13 @@ private String constructLogPattern(String logPathFromConfig) throws SnowflakeSQL
 
     String logPattern = "%t/snowflake_jdbc%u.log"; // java.tmpdir
 
+    Path logPath;
     if (logPathFromConfig != null && !logPathFromConfig.isEmpty()) {
-      Path path = Paths.get(logPathFromConfig, "jdbc");
-      if (!Files.exists(path)) {
+      // Get log path from configuration
+      logPath = Paths.get(logPathFromConfig);
+      if (!Files.exists(logPath)) {
         try {
-          Files.createDirectories(path);
+          Files.createDirectories(logPath);
         } catch (IOException ex) {
           throw new SnowflakeSQLLoggedException(
               sfSession,
@@ -220,11 +227,82 @@ private String constructLogPattern(String logPathFromConfig) throws SnowflakeSQL
                   logPathFromConfig, ex.getMessage()));
         }
       }
-      logPattern = Paths.get(path.toString(), "snowflake_jdbc%u.log").toString();
+    } else {
+      // Get log path from home directory
+      String homePath = systemGetProperty("user.home");
+      if (homePath == null || homePath.isEmpty()) {
+        throw new SnowflakeSQLLoggedException(
+            sfSession,
+            ErrorCode.INTERNAL_ERROR,
+            String.format(
+                "Log path not set in configfile %s and home directory not set.",
+                logPathFromConfig));
+      }
+      logPath = Paths.get(homePath);
     }
+
+    Path path = createLogPathSubDirectory(logPath);
+
+    logPattern = Paths.get(path.toString(), "snowflake_jdbc%u.log").toString();
     return logPattern;
   }
 
+  private Path createLogPathSubDirectory(Path logPath) throws SnowflakeSQLLoggedException {
+    Path path = Paths.get(logPath.toString(), "jdbc");
+    if (!Files.exists(path)) {
+      createLogFolder(path);
+    } else {
+      checkLogFolderPermissions(path);
+    }
+    return path;
+  }
+
+  private void createLogFolder(Path path) throws SnowflakeSQLLoggedException {
+    try {
+      if (Constants.getOS() == Constants.OS.WINDOWS) {
+        Files.createDirectories(path);
+      } else {
+        Files.createDirectories(
+            path,
+            PosixFilePermissions.asFileAttribute(PosixFilePermissions.fromString("rwx------")));
+      }
+    } catch (IOException ex) {
+      throw new SnowflakeSQLLoggedException(
+          sfSession,
+          ErrorCode.INTERNAL_ERROR,
+          String.format(
+              "Unable to create jdbc subfolder in configfile %s ,%s",
+              path.toString(), ex.getMessage(), ex.getCause()));
+    }
+  }
+
+  private void checkLogFolderPermissions(Path path) throws SnowflakeSQLLoggedException {
+    if (Constants.getOS() != Constants.OS.WINDOWS) {
+      try {
+        Set<PosixFilePermission> folderPermissions = Files.getPosixFilePermissions(path);
+        if (folderPermissions.contains(PosixFilePermission.GROUP_WRITE)
+            || folderPermissions.contains(PosixFilePermission.GROUP_READ)
+            || folderPermissions.contains(PosixFilePermission.GROUP_EXECUTE)
+            || folderPermissions.contains(PosixFilePermission.OTHERS_WRITE)
+            || folderPermissions.contains(PosixFilePermission.OTHERS_READ)
+            || folderPermissions.contains(PosixFilePermission.OTHERS_EXECUTE)) {
+          logger.info(
+              "Access permission for the logs directory '{}' is currently {} and is potentially "
+                  + "accessible to users other than the owner of the logs directory.",
+              path.toString(),
+              folderPermissions.toString());
+        }
+      } catch (IOException ex) {
+        throw new SnowflakeSQLLoggedException(
+            sfSession,
+            ErrorCode.INTERNAL_ERROR,
+            String.format(
+                "Un-able to get permissions of log directory %s ,%s",
+                path.toString(), ex.getMessage(), ex.getCause()));
+      }
+    }
+  }
+
   private void initSessionProperties(SnowflakeConnectString conStr, String appID, String appVersion)
       throws SFException {
     Map<String, Object> properties = mergeProperties(conStr);

src/test/java/net/snowflake/client/RunningOnWin.java

@@ -0,0 +1,9 @@
+package net.snowflake.client;
+
+import net.snowflake.client.core.Constants;
+
+public class RunningOnWin implements ConditionalIgnoreRule.IgnoreCondition {
+  public boolean isSatisfied() {
+    return Constants.getOS() == Constants.OS.WINDOWS;
+  }
+}