From 23a597e12e111e8a7717bd195938d74da049513f Mon Sep 17 00:00:00 2001 From: Neenu1995 Date: Fri, 20 Nov 2026 15:05:05 -0500 Subject: [PATCH] fix(bigquery-jdbc): redact URL property logs and isolate per-connection logging Resolves b/584840083 (PR 2 of 3). Redacts sensitive properties (including BYOID_CredentialSource) via SAFE_TO_LOG_PROPERTIES in BigQueryJdbcUrlUtility.appendPropertiesToURL, isolates per-connection LogLevel and LogPath inside a single persistent PerConnectionFileHandler without stripping OpenTelemetryJulHandler or external JUL handlers on LogLevel=0, makes BigQueryJdbcMdc.registerInstance reentrant, and adds -Dcom.google.cloud.bigquery.jdbc.allowUrlLogPath for multi-tenant deployments. --- .../bigquery/jdbc/BigQueryConnection.java | 23 ++- .../cloud/bigquery/jdbc/BigQueryDriver.java | 192 ++++++++++-------- .../cloud/bigquery/jdbc/BigQueryJdbcMdc.java | 19 +- .../bigquery/jdbc/BigQueryJdbcRootLogger.java | 179 +++++++++++++++- .../bigquery/jdbc/BigQueryJdbcUrlUtility.java | 34 +++- .../jdbc/PerConnectionFileHandler.java | 81 +++++++- .../bigquery/jdbc/BigQueryConnectionTest.java | 13 +- .../bigquery/jdbc/BigQueryDriverTest.java | 189 ++++++++++++++++- .../jdbc/BigQueryJdbcLoggingBaseTest.java | 8 +- .../bigquery/jdbc/BigQueryJdbcMdcTest.java | 17 ++ .../jdbc/BigQueryJdbcUrlUtilityTest.java | 57 ++++++ .../jdbc/PerConnectionFileHandlerTest.java | 22 +- 12 files changed, 711 insertions(+), 123 deletions(-) diff --git a/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryConnection.java b/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryConnection.java index 6fc7dd168d24..c72bae6f8a58 100644 --- a/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryConnection.java +++ b/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryConnection.java @@ -155,7 +155,6 @@ public class BigQueryConnection extends BigQueryNoOpsConnection { BigQueryJdbcUrlUtility.HTTP_CONNECT_TIMEOUT_PROPERTY_NAME, BigQueryJdbcUrlUtility.HTTP_READ_TIMEOUT_PROPERTY_NAME, BigQueryJdbcUrlUtility.BYOID_AUDIENCE_URI_PROPERTY_NAME, - BigQueryJdbcUrlUtility.BYOID_CREDENTIAL_SOURCE_PROPERTY_NAME, BigQueryJdbcUrlUtility.BYOID_POOL_USER_PROJECT_PROPERTY_NAME, BigQueryJdbcUrlUtility.BYOID_SA_IMPERSONATION_URI_PROPERTY_NAME, BigQueryJdbcUrlUtility.BYOID_SUBJECT_TOKEN_TYPE_PROPERTY_NAME, @@ -264,12 +263,26 @@ public class BigQueryConnection extends BigQueryNoOpsConnection { private final AtomicReference sessionState = new AtomicReference<>(new SessionState(null, Collections.emptyList(), false)); + static String maskPropertyValue(String key, Object value) { + if (value == null) { + return null; + } + if (key == null || !SAFE_TO_LOG_PROPERTIES.contains(key)) { + return "*****"; + } + return String.valueOf(value); + } + BigQueryConnection(String url) throws SQLException { this(url, DataSource.fromUrl(url)); } BigQueryConnection(String url, DataSource ds) throws SQLException { - this.connectionId = UUID.randomUUID().toString(); + this(url, ds, UUID.randomUUID().toString()); + } + + BigQueryConnection(String url, DataSource ds, String connectionId) throws SQLException { + this.connectionId = connectionId != null ? connectionId : UUID.randomUUID().toString(); Baggage baggage = Baggage.builder() .put(BigQueryJdbcOpenTelemetry.CONNECTION_ID_BAGGAGE_KEY, this.connectionId) @@ -285,11 +298,7 @@ public class BigQueryConnection extends BigQueryNoOpsConnection { Properties connectionProps = ds.createProperties(); Properties maskedProps = new Properties(); for (String name : connectionProps.stringPropertyNames()) { - String value = connectionProps.getProperty(name); - if (!SAFE_TO_LOG_PROPERTIES.contains(name)) { - value = "*****"; - } - maskedProps.setProperty(name, value); + maskedProps.setProperty(name, maskPropertyValue(name, connectionProps.getProperty(name))); } LOG.config("Connection properties: %s", maskedProps.toString()); } diff --git a/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryDriver.java b/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryDriver.java index 67e74d74c114..f16572ea5a87 100644 --- a/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryDriver.java +++ b/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryDriver.java @@ -36,6 +36,7 @@ import java.util.List; import java.util.Map; import java.util.Properties; +import java.util.UUID; import java.util.logging.Level; import java.util.logging.Logger; @@ -131,98 +132,129 @@ public Connection connect(String url, Properties info) throws SQLException { AuthenticationType authType = AuthenticationType.AUTHENTICATION_TYPE_UNSPECIFIED; try { if (acceptsURL(url)) { - Properties connectInfo = info == null ? new Properties() : (Properties) info.clone(); - Object customOpenTelemetryObj = connectInfo.remove("customOpenTelemetry"); + String connectionId = UUID.randomUUID().toString(); + BigQueryConnection connection = null; + boolean connectionReturned = false; + try (BigQueryJdbcMdc.MdcCloseable mdc = BigQueryJdbcMdc.registerInstance(connectionId)) { + Properties connectInfo = info == null ? new Properties() : (Properties) info.clone(); + Object customOpenTelemetryObj = connectInfo.remove("customOpenTelemetry"); - String connectionUri = - BigQueryJdbcUrlUtility.appendPropertiesToURL( - url.substring(5), this.toString(), connectInfo); + String connectionUri = + BigQueryJdbcUrlUtility.appendPropertiesToURL( + url.substring(5), this.toString(), connectInfo); - String telemetryOptOut = - BigQueryJdbcUrlUtility.parseUriPropertyWithoutValidation( - connectionUri, BigQueryJdbcUrlUtility.ENABLE_DIAGNOSTIC_TELEMETRY_PROPERTY_NAME); - - if (telemetryOptOut != null) { - connectInfo.setProperty( - BigQueryJdbcUrlUtility.ENABLE_DIAGNOSTIC_TELEMETRY_PROPERTY_NAME, telemetryOptOut); - } - TelemetryManager.getInstance(connectInfo); - - Level logLevel; - String logPath; - try { - // LogLevel - String logLevelStr = + String telemetryOptOut = BigQueryJdbcUrlUtility.parseUriPropertyWithoutValidation( - connectionUri, BigQueryJdbcUrlUtility.LOG_LEVEL_PROPERTY_NAME); - if (logLevelStr == null) { - logLevelStr = System.getenv(BigQueryJdbcUrlUtility.LOG_LEVEL_ENV_VAR); + connectionUri, BigQueryJdbcUrlUtility.ENABLE_DIAGNOSTIC_TELEMETRY_PROPERTY_NAME); + + if (telemetryOptOut != null) { + connectInfo.setProperty( + BigQueryJdbcUrlUtility.ENABLE_DIAGNOSTIC_TELEMETRY_PROPERTY_NAME, telemetryOptOut); } - logLevel = BigQueryJdbcUrlUtility.parseLogLevel(logLevelStr); + TelemetryManager.getInstance(connectInfo); - // LogPath - logPath = - BigQueryJdbcUrlUtility.parseUriPropertyWithoutValidation( - connectionUri, BigQueryJdbcUrlUtility.LOG_PATH_PROPERTY_NAME); - if (logPath == null) { - logPath = System.getenv(BigQueryJdbcUrlUtility.LOG_PATH_ENV_VAR); + Level logLevel; + String logPath; + try { + // LogLevel + String logLevelStr = + BigQueryJdbcUrlUtility.parseUriPropertyWithoutValidation( + connectionUri, BigQueryJdbcUrlUtility.LOG_LEVEL_PROPERTY_NAME); + if (logLevelStr == null) { + logLevelStr = System.getenv(BigQueryJdbcUrlUtility.LOG_LEVEL_ENV_VAR); + } + logLevel = BigQueryJdbcUrlUtility.parseLogLevel(logLevelStr); + + // LogPath + String urlLogPath = + BigQueryJdbcUrlUtility.parseUriPropertyWithoutValidation( + connectionUri, BigQueryJdbcUrlUtility.LOG_PATH_PROPERTY_NAME); + String envLogPath = System.getenv(BigQueryJdbcUrlUtility.LOG_PATH_ENV_VAR); + boolean allowUrlLogPath = BigQueryJdbcUrlUtility.isUrlLogPathAllowed(); + + String enableGcpLogExporterStr = + BigQueryJdbcUrlUtility.parseUriPropertyWithoutValidation( + connectionUri, BigQueryJdbcUrlUtility.ENABLE_GCP_LOG_EXPORTER_PROPERTY_NAME); + boolean enableGcpLogExporter = false; + if (enableGcpLogExporterStr != null) { + enableGcpLogExporter = + BigQueryJdbcUrlUtility.convertToBoolean( + enableGcpLogExporterStr, + BigQueryJdbcUrlUtility.ENABLE_GCP_LOG_EXPORTER_PROPERTY_NAME); + } + + boolean ignoredUrlLogPath = false; + if (allowUrlLogPath) { + logPath = urlLogPath != null ? urlLogPath : envLogPath; + // Fallback to default path only if not specified and not in Cloud-Only mode + if (logPath == null && !enableGcpLogExporter) { + logPath = BigQueryJdbcUrlUtility.DEFAULT_LOG_PATH; + } + } else { + ignoredUrlLogPath = urlLogPath != null; + logPath = envLogPath; + } + + BigQueryJdbcRootLogger.registerConnection(connectionId, logLevel, logPath); + if (ignoredUrlLogPath) { + LOG.warning( + "Ignoring URL/Properties %s because system property %s is false.", + BigQueryJdbcUrlUtility.LOG_PATH_PROPERTY_NAME, + BigQueryJdbcUrlUtility.ALLOW_URL_LOG_PATH_SYSTEM_PROPERTY); + } + } catch (RuntimeException e) { + LOG.log(Level.SEVERE, "Failed to parse connection URL properties", e); + throw new BigQueryJdbcException("Failed to parse connection URL properties", e); } - // Fallback to default path only if not specified and not in Cloud-Only mode - String enableGcpLogExporterStr = - BigQueryJdbcUrlUtility.parseUriPropertyWithoutValidation( - connectionUri, BigQueryJdbcUrlUtility.ENABLE_GCP_LOG_EXPORTER_PROPERTY_NAME); - boolean enableGcpLogExporter = false; - if (enableGcpLogExporterStr != null) { - enableGcpLogExporter = - BigQueryJdbcUrlUtility.convertToBoolean( - enableGcpLogExporterStr, - BigQueryJdbcUrlUtility.ENABLE_GCP_LOG_EXPORTER_PROPERTY_NAME); + // Logging starts from here. + DataSource ds; + try { + ds = DataSource.fromUrl(connectionUri); + } catch (BigQueryJdbcRuntimeException e) { + LOG.log(Level.SEVERE, "Failed to parse connection URL", e); + throw new BigQueryJdbcException("Failed to parse connection URL", e); } - if (logPath == null && !enableGcpLogExporter) { - logPath = BigQueryJdbcUrlUtility.DEFAULT_LOG_PATH; + authType = TelemetryManager.toAuthenticationType(ds.getOAuthType()); + if (customOpenTelemetryObj instanceof OpenTelemetry) { + ds.setCustomOpenTelemetry((OpenTelemetry) customOpenTelemetryObj); } + connection = new BigQueryConnection(connectionUri, ds, connectionId); + DatabaseMetaData metaData = connection.getMetaData(); + LOG.info( + "Driver info : { {Database Product Name : %s}, " + + "{Database Product Version : %s}, " + + "{Driver Name : %s}, " + + "{Driver Version : %s}, " + + "{LogLevel : %s}, " + + "{LogPath : %s}, " + + "{Driver Instance : %s} }", + metaData.getDatabaseProductName(), + metaData.getDatabaseProductVersion(), + metaData.getDriverName(), + metaData.getDriverVersion(), + logLevel, + logPath, + this.toString()); - BigQueryJdbcRootLogger.setLevel(logLevel, logPath); - } catch (RuntimeException e) { - LOG.log(Level.SEVERE, "Failed to parse connection URL properties", e); - throw new BigQueryJdbcException("Failed to parse connection URL properties", e); - } + Connection wrapped = BigQueryJdbcContextProxy.wrap(connection, Connection.class); - // Logging starts from here. - DataSource ds; - try { - ds = DataSource.fromUrl(connectionUri); - } catch (BigQueryJdbcRuntimeException e) { - LOG.log(Level.SEVERE, "Failed to parse connection URL", e); - throw new BigQueryJdbcException("Failed to parse connection URL", e); - } - authType = TelemetryManager.toAuthenticationType(ds.getOAuthType()); - if (customOpenTelemetryObj instanceof OpenTelemetry) { - ds.setCustomOpenTelemetry((OpenTelemetry) customOpenTelemetryObj); + TelemetryManager.recordConnectionAttempt(Status.STATUS_SUCCESS, 0, authType); + connectionReturned = true; + return wrapped; + } finally { + if (!connectionReturned) { + if (connection != null) { + try { + connection.close(); + } catch (SQLException ignored) { + BigQueryJdbcRootLogger.closeConnectionHandler(connectionId); + } + } else { + BigQueryJdbcRootLogger.closeConnectionHandler(connectionId); + } + } } - BigQueryConnection connection = new BigQueryConnection(connectionUri, ds); - DatabaseMetaData metaData = connection.getMetaData(); - LOG.info( - "Driver info : { {Database Product Name : %s}, " - + "{Database Product Version : %s}, " - + "{Driver Name : %s}, " - + "{Driver Version : %s}, " - + "{LogLevel : %s}, " - + "{LogPath : %s}, " - + "{Driver Instance : %s} }", - metaData.getDatabaseProductName(), - metaData.getDatabaseProductVersion(), - metaData.getDriverName(), - metaData.getDriverVersion(), - logLevel, - logPath, - this.toString()); - - Connection wrapped = BigQueryJdbcContextProxy.wrap(connection, Connection.class); - - TelemetryManager.recordConnectionAttempt(Status.STATUS_SUCCESS, 0, authType); - return wrapped; } else { return null; } diff --git a/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcMdc.java b/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcMdc.java index 254cdc5cc2fa..0e76c5ec1494 100644 --- a/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcMdc.java +++ b/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcMdc.java @@ -36,12 +36,23 @@ class BigQueryJdbcMdc { private static final InheritableThreadLocal currentConnectionId = new InheritableThreadLocal<>(); - /** Sets the current connection context on the executing thread. */ + /** + * Sets the current connection context on the executing thread and restores any enclosing context + * upon close. + */ static MdcCloseable registerInstance(String connectionId) { - if (connectionId != null) { - currentConnectionId.set(connectionId); + if (connectionId == null) { + return () -> {}; } - return () -> clear(); + String previous = currentConnectionId.get(); + currentConnectionId.set(connectionId); + return () -> { + if (previous != null) { + currentConnectionId.set(previous); + } else { + clear(); + } + }; } /** diff --git a/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcRootLogger.java b/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcRootLogger.java index 14bb9886aba8..e63be3d77e3a 100644 --- a/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcRootLogger.java +++ b/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcRootLogger.java @@ -47,7 +47,12 @@ class BigQueryJdbcRootLogger { private static final ConcurrentHashMap ACTIVE_CONNECTIONS = new ConcurrentHashMap<>(); + private static ConsoleHandler testConsoleHandler = null; + private static volatile PerConnectionFileHandler persistentFileHandler = null; private static volatile Handler fileHandler = null; + private static volatile Level explicitGlobalLevel = Level.OFF; + private static Level lastDriverAppliedLevel = null; + private static Level externalFloorLevel = null; static final String PROCESS_ID = ManagementFactory.getRuntimeMXBean().getName().split("@")[0]; @@ -82,6 +87,7 @@ static String getThreadName(long threadId) { ConsoleHandler consoleHandler = new ConsoleHandler(); consoleHandler.setLevel(Level.SEVERE); consoleHandler.setFormatter(getFormatter()); + testConsoleHandler = consoleHandler; logger.addHandler(consoleHandler); } } @@ -165,19 +171,114 @@ public static Logger getRootLogger() { return logger; } - public static synchronized void setLevel(Level level, String logPath) throws IOException { - if (level != Level.OFF) { - if (logPath != null) { - setPath(logPath, level); + private static synchronized PerConnectionFileHandler ensurePersistentFileHandlerAttached() { + if (persistentFileHandler == null) { + persistentFileHandler = new PerConnectionFileHandler(); + } + boolean attached = false; + for (Handler h : logger.getHandlers()) { + if (h == persistentFileHandler) { + attached = true; + break; + } + } + if (!attached) { + logger.addHandler(persistentFileHandler); + logger.setUseParentHandlers(false); + } + return persistentFileHandler; + } + + private static boolean isDriverOwnedHandler(Handler handler) { + return handler instanceof PerConnectionFileHandler + || handler instanceof OpenTelemetryJulHandler + || (testConsoleHandler != null && handler == testConsoleHandler); + } + + private static boolean hasExternalHandlerAttached() { + for (Handler h : logger.getHandlers()) { + if (!isDriverOwnedHandler(h)) { + return true; + } + } + return false; + } + + private static synchronized void refreshEffectiveRootLevel() { + Level current = logger.getLevel(); + if (hasExternalHandlerAttached()) { + if (current != lastDriverAppliedLevel) { + externalFloorLevel = current; } } else { - for (Handler h : logger.getHandlers()) { - h.close(); - logger.removeHandler(h); + externalFloorLevel = null; + } + + int targetValue = + explicitGlobalLevel != null + ? explicitGlobalLevel.intValue() + : ConnectionLogContext.OFF_VALUE; + String envLevelStr = System.getenv(BigQueryJdbcUrlUtility.LOG_LEVEL_ENV_VAR); + if (envLevelStr != null) { + try { + targetValue = + Math.min(targetValue, BigQueryJdbcUrlUtility.parseLogLevel(envLevelStr).intValue()); + } catch (RuntimeException ignored) { + // Invalid env level falls back to active connection levels. } + } + for (ConnectionLogContext ctx : ACTIVE_CONNECTIONS.values()) { + targetValue = Math.min(targetValue, ctx.levelValue()); + } + if (externalFloorLevel != null) { + targetValue = Math.min(targetValue, externalFloorLevel.intValue()); + } + Level applied = toJulLevel(targetValue); + lastDriverAppliedLevel = applied; + logger.setLevel(applied); + } + + private static Level toJulLevel(int levelValue) { + if (levelValue <= Level.ALL.intValue()) { + return Level.ALL; + } + if (levelValue <= Level.FINEST.intValue()) { + return Level.FINEST; + } + if (levelValue <= Level.FINER.intValue()) { + return Level.FINER; + } + if (levelValue <= Level.FINE.intValue()) { + return Level.FINE; + } + if (levelValue <= Level.CONFIG.intValue()) { + return Level.CONFIG; + } + if (levelValue <= Level.INFO.intValue()) { + return Level.INFO; + } + if (levelValue <= Level.WARNING.intValue()) { + return Level.WARNING; + } + if (levelValue <= Level.SEVERE.intValue()) { + return Level.SEVERE; + } + return Level.OFF; + } + + public static synchronized void setLevel(Level level, String logPath) throws IOException { + Level effective = level != null ? level : Level.OFF; + explicitGlobalLevel = effective; + if (effective != Level.OFF) { + if (logPath != null) { + setPath(logPath, effective); + } + } else if (fileHandler != null) { + fileHandler.close(); + logger.removeHandler(fileHandler); fileHandler = null; } - logger.setLevel(level); + refreshEffectiveRootLevel(); } static synchronized void setPath(String logPath, Level level) { @@ -210,7 +311,7 @@ static ConnectionLogContext registerConnection(String connectionId) { } ConnectionLogContext context = ACTIVE_CONNECTIONS.computeIfAbsent( - connectionId, id -> new ConnectionLogContext(id, ConnectionLogContext.ALL_VALUE)); + connectionId, id -> new ConnectionLogContext(id, ConnectionLogContext.OFF_VALUE)); Handler currentHandler = fileHandler; if (currentHandler instanceof PerConnectionFileHandler) { ((PerConnectionFileHandler) currentHandler).registerConnection(connectionId); @@ -218,6 +319,41 @@ static ConnectionLogContext registerConnection(String connectionId) { return context; } + static synchronized ConnectionLogContext registerConnection( + String connectionId, Level level, String logPath) throws IOException { + if (connectionId == null || connectionId.isEmpty()) { + return null; + } + Level effectiveLevel = level != null ? level : Level.OFF; + ConnectionLogContext context = + ACTIVE_CONNECTIONS.compute( + connectionId, + (id, existing) -> { + if (existing == null) { + return new ConnectionLogContext(id, effectiveLevel.intValue()); + } + existing.setLevelValue(effectiveLevel.intValue()); + return existing; + }); + try { + if (effectiveLevel != Level.OFF && logPath != null) { + PerConnectionFileHandler persistent = ensurePersistentFileHandlerAttached(); + persistent.registerConnection(connectionId, effectiveLevel, logPath); + } + Handler legacy = fileHandler; + if (legacy instanceof PerConnectionFileHandler) { + ((PerConnectionFileHandler) legacy).registerConnection(connectionId); + } + refreshEffectiveRootLevel(); + return context; + } catch (IOException | RuntimeException ex) { + ACTIVE_CONNECTIONS.remove(connectionId, context); + context.setLevelValue(ConnectionLogContext.OFF_VALUE); + refreshEffectiveRootLevel(); + throw ex; + } + } + static ConnectionLogContext findActiveContext(String connectionId) { if (connectionId == null || connectionId.isEmpty()) { return null; @@ -233,7 +369,7 @@ static int activeConnectionCount() { return ACTIVE_CONNECTIONS.size(); } - public static void closeConnectionHandler(String connectionId) { + public static synchronized void closeConnectionHandler(String connectionId) { if (connectionId == null) { return; } @@ -241,9 +377,32 @@ public static void closeConnectionHandler(String connectionId) { if (removed != null) { removed.setLevelValue(ConnectionLogContext.OFF_VALUE); } + if (persistentFileHandler != null) { + persistentFileHandler.closeHandler(connectionId); + } Handler currentHandler = fileHandler; if (currentHandler instanceof PerConnectionFileHandler) { ((PerConnectionFileHandler) currentHandler).closeHandler(connectionId); } + refreshEffectiveRootLevel(); + } + + static synchronized void resetForTesting() { + for (String id : ACTIVE_CONNECTIONS.keySet()) { + ConnectionLogContext ctx = ACTIVE_CONNECTIONS.remove(id); + if (ctx != null) { + ctx.setLevelValue(ConnectionLogContext.OFF_VALUE); + } + if (persistentFileHandler != null) { + persistentFileHandler.closeHandler(id); + } + } + if (fileHandler != null) { + fileHandler.close(); + logger.removeHandler(fileHandler); + fileHandler = null; + } + explicitGlobalLevel = Level.OFF; + refreshEffectiveRootLevel(); } } diff --git a/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcUrlUtility.java b/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcUrlUtility.java index d22846470081..8ed7bb87bb9f 100644 --- a/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcUrlUtility.java +++ b/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcUrlUtility.java @@ -123,6 +123,8 @@ protected boolean removeEldestEntry(Map.Entry> eldes static final String LOG_PATH_PROPERTY_NAME = "LogPath"; static final String LOG_LEVEL_ENV_VAR = "BIGQUERY_JDBC_LOG_LEVEL"; static final String LOG_PATH_ENV_VAR = "BIGQUERY_JDBC_LOG_PATH"; + static final String ALLOW_URL_LOG_PATH_SYSTEM_PROPERTY = + "com.google.cloud.bigquery.jdbc.allowUrlLogPath"; static final String ENABLE_SESSION_PROPERTY_NAME = "EnableSession"; static final String ENABLE_TIMESTAMP_PICOS_PROPERTY_NAME = "EnableTimestampPicos"; static final boolean DEFAULT_ENABLE_TIMESTAMP_PICOS_VALUE = false; @@ -852,17 +854,33 @@ private static Map parseUrlInternal(String url) { * @param properties The properties to append. * @return The string value of the updated URL. */ + static boolean isUrlLogPathAllowed() { + String prop = System.getProperty(ALLOW_URL_LOG_PATH_SYSTEM_PROPERTY); + return prop == null || !"false".equalsIgnoreCase(prop.trim()); + } + static String appendPropertiesToURL(String url, String callerClassName, Properties properties) { - LOG.finest("++enter++ " + callerClassName); + LOG.finest(() -> "++enter++ " + callerClassName); + if (properties == null || properties.isEmpty()) { + return url; + } StringBuilder urlBuilder = new StringBuilder(url); for (Entry entry : properties.entrySet()) { - if (entry.getValue() != null && !"".equals(entry.getValue())) { - LOG.finest("Appending %s with value %s to URL", entry.getKey(), entry.getValue()); - String encodedValue = - UrlEscapers.urlFormParameterEscaper() - .escape((String) entry.getValue()) - .replace("+", "%20"); - urlBuilder.append(";").append(entry.getKey()).append("=").append(encodedValue); + Object rawKey = entry.getKey(); + Object rawValue = entry.getValue(); + if (rawKey != null && rawValue != null) { + String key = String.valueOf(rawKey); + String valueStr = String.valueOf(rawValue); + if (!valueStr.isEmpty()) { + LOG.finest( + () -> + String.format( + "Appending %s with value %s to URL", + key, BigQueryConnection.maskPropertyValue(key, valueStr))); + String encodedValue = + UrlEscapers.urlFormParameterEscaper().escape(valueStr).replace("+", "%20"); + urlBuilder.append(";").append(key).append("=").append(encodedValue); + } } } return urlBuilder.toString(); diff --git a/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/PerConnectionFileHandler.java b/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/PerConnectionFileHandler.java index f743e08d2814..d07e0aea534f 100644 --- a/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/PerConnectionFileHandler.java +++ b/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/PerConnectionFileHandler.java @@ -71,12 +71,47 @@ class PerConnectionFileHandler extends Handler { private final Path baseLogPath; private final Level level; private final int maxFileBytes; + private final boolean allowImplicitSlots; private final Formatter logFormatter; private final Set registeredConnections = ConcurrentHashMap.newKeySet(); private final ConcurrentHashMap slots = new ConcurrentHashMap<>(); private final BoundedLogFileWriter defaultWriter; private volatile boolean handlerClosed = false; + /** + * Persistent multi-connection handler used by {@link BigQueryJdbcRootLogger}. Each connection + * registers its own {@code (logPath, level)} slot; a global fallback writer is opened only when + * JVM-wide {@code BIGQUERY_JDBC_LOG_PATH} and {@code BIGQUERY_JDBC_LOG_LEVEL} environment + * variables are configured. + */ + PerConnectionFileHandler() { + this.level = Level.ALL; + this.maxFileBytes = resolveMaxLogFileBytes(); + this.allowImplicitSlots = false; + this.logFormatter = BigQueryJdbcRootLogger.getFormatter(); + setLevel(Level.ALL); + setFormatter(this.logFormatter); + + String envLogPath = System.getenv(BigQueryJdbcUrlUtility.LOG_PATH_ENV_VAR); + String envLogLevelStr = System.getenv(BigQueryJdbcUrlUtility.LOG_LEVEL_ENV_VAR); + BoundedLogFileWriter initializedDefault = null; + if (envLogPath != null && envLogLevelStr != null) { + try { + Level envLevel = BigQueryJdbcUrlUtility.parseLogLevel(envLogLevelStr); + if (envLevel != Level.OFF) { + Path verifiedEnvDir = ensureSecureDirectory(Paths.get(envLogPath).toAbsolutePath()); + initializedDefault = + createLogWriter(DEFAULT_HANDLER_ID, verifiedEnvDir, envLevel, this.maxFileBytes); + } + } catch (RuntimeException | IOException e) { + Exception ex = (e instanceof Exception) ? (Exception) e : new IOException(e); + reportError("Failed to initialize env default log file", ex, ErrorManager.OPEN_FAILURE); + } + } + this.baseLogPath = null; + this.defaultWriter = initializedDefault; + } + PerConnectionFileHandler(String baseLogPath, Level level) { this(baseLogPath, level, resolveMaxLogFileBytes()); } @@ -85,6 +120,7 @@ class PerConnectionFileHandler extends Handler { PerConnectionFileHandler(String baseLogPath, Level level, int maxFileBytes) { this.level = level; this.maxFileBytes = maxFileBytes > 0 ? maxFileBytes : DEFAULT_MAX_LOG_FILE_BYTES; + this.allowImplicitSlots = true; this.logFormatter = BigQueryJdbcRootLogger.getFormatter(); setLevel(level); setFormatter(this.logFormatter); @@ -245,7 +281,16 @@ private BoundedLogFileWriter createLogWriter( try { Path verifiedDir = ensureSecureDirectory(logDir); SeekableByteChannel channel = openChannelForId(verifiedDir, id); - return new BoundedLogFileWriter(channel, writerLevel, limitBytes, logFormatter, this); + try { + return new BoundedLogFileWriter(channel, writerLevel, limitBytes, logFormatter, this); + } catch (IOException initEx) { + try { + channel.close(); + } catch (IOException closeEx) { + initEx.addSuppressed(closeEx); + } + throw initEx; + } } catch (IOException e) { reportError("Failed to create log file for connection " + id, e, ErrorManager.OPEN_FAILURE); return null; @@ -300,8 +345,29 @@ void registerConnection(String connectionId) { registeredConnections.add(connectionId); } + void registerConnection(String connectionId, Level connectionLevel, String connectionLogPath) + throws IOException { + if (connectionId == null + || connectionId.isEmpty() + || handlerClosed + || connectionLevel == null + || connectionLevel == Level.OFF + || connectionLogPath == null) { + return; + } + Path verifiedDir = ensureSecureDirectory(Paths.get(connectionLogPath).toAbsolutePath()); + registeredConnections.add(connectionId); + ConnectionFileSlot previous = + slots.put(connectionId, new ConnectionFileSlot(verifiedDir, connectionLevel, maxFileBytes)); + if (previous != null) { + previous.closeSlot(); + } + } + private boolean canOpenSlotFor(String connectionId) { return !handlerClosed + && allowImplicitSlots + && baseLogPath != null && (registeredConnections.contains(connectionId) || BigQueryJdbcRootLogger.isConnectionActive(connectionId)); } @@ -336,6 +402,11 @@ public void publish(LogRecord record) { if (slot != null && slot.publishIfOpen(record, connectionId, this)) { return; } + if (!allowImplicitSlots) { + // On the persistent multi-connection handler, connection-attributed records without an + // active file slot (e.g., LogLevel=0 or Cloud-Only mode) must not spill to defaultWriter. + return; + } } if (!handlerClosed && defaultWriter != null) { @@ -491,11 +562,17 @@ synchronized boolean isClosed() { synchronized boolean publishIfOpen( LogRecord record, String connectionId, PerConnectionFileHandler owner) { - if (closed || owner.handlerClosed || !owner.canOpenSlotFor(connectionId)) { + if (closed + || owner.handlerClosed + || (!owner.registeredConnections.contains(connectionId) + && !BigQueryJdbcRootLogger.isConnectionActive(connectionId))) { closeSlot(); owner.slots.remove(connectionId, this); return false; } + if (record.getLevel().intValue() < level.intValue()) { + return true; + } if (writer == null) { writer = owner.createLogWriter(connectionId, logPath, level, maxFileBytes); if (writer == null) { diff --git a/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/BigQueryConnectionTest.java b/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/BigQueryConnectionTest.java index fd82c6babb62..037681785442 100644 --- a/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/BigQueryConnectionTest.java +++ b/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/BigQueryConnectionTest.java @@ -564,7 +564,9 @@ public void testConnectionPropertiesLoggingAndMasking() throws IOException, SQLE String url = "jdbc:bigquery://https://www.googleapis.com/bigquery/v2:443;" + "OAuthType=2;ProjectId=MyTestProjectId;" - + "OAuthAccessToken=secretAccessToken;Location=US;"; + + "OAuthAccessToken=secretAccessToken;" + + "ProxyHost=proxy.example.com;ProxyPort=8080;ProxyUid=secretProxyUid;ProxyPwd=secretProxyPwd;" + + "Location=US;"; try (BigQueryConnection connection = new BigQueryConnection(url)) { // Just trigger the constructor } @@ -580,7 +582,16 @@ public void testConnectionPropertiesLoggingAndMasking() throws IOException, SQLE assertTrue(logMessage.contains("ProjectId=MyTestProjectId")); assertTrue(logMessage.contains("Location=US")); assertTrue(logMessage.contains("OAuthAccessToken=*****")); + assertTrue(logMessage.contains("ProxyUid=*****")); + assertTrue(logMessage.contains("ProxyPwd=*****")); assertFalse(logMessage.contains("secretAccessToken")); + assertFalse(logMessage.contains("secretProxyUid")); + assertFalse(logMessage.contains("secretProxyPwd")); + assertEquals( + "*****", + BigQueryConnection.maskPropertyValue( + BigQueryJdbcUrlUtility.BYOID_CREDENTIAL_SOURCE_PROPERTY_NAME, + "{\"headers\":{\"Authorization\":\"Bearer secretByoid\"}}")); } finally { rootLogger.setLevel(originalLevel); } diff --git a/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/BigQueryDriverTest.java b/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/BigQueryDriverTest.java index c98e8dfabb53..0f51b338b47a 100644 --- a/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/BigQueryDriverTest.java +++ b/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/BigQueryDriverTest.java @@ -33,16 +33,28 @@ import com.google.cloud.bigquery.jdbc.utils.BigQueryJdbcVersionUtility; import io.opentelemetry.api.OpenTelemetry; import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; import java.sql.Connection; import java.sql.DriverPropertyInfo; +import java.sql.ResultSet; import java.sql.SQLException; +import java.util.Arrays; +import java.util.List; import java.util.Properties; +import java.util.logging.Handler; import java.util.logging.Level; +import java.util.logging.LogRecord; import java.util.logging.Logger; +import java.util.stream.Collectors; +import java.util.stream.Stream; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; import org.mockito.MockedStatic; public class BigQueryDriverTest extends BigQueryJdbcLoggingBaseTest { @@ -278,12 +290,12 @@ public void testConnect_failedAttemptCarriesAuthType() { @Test public void testConnect_ioExceptionThrowsInsteadOfReturningNull() { - // BigQueryJdbcRootLogger.setLevel is the only IOException source on the connect path. JDBC - // requires connect() to throw for an accepted URL that fails, not return null. + // BigQueryJdbcRootLogger.registerConnection is the IOException source on the connect path. + // JDBC requires connect() to throw for an accepted URL that fails, not return null. try (MockedStatic rootLogger = mockStatic(BigQueryJdbcRootLogger.class)) { rootLogger - .when(() -> BigQueryJdbcRootLogger.setLevel(any(), any())) + .when(() -> BigQueryJdbcRootLogger.registerConnection(any(), any(), any())) .thenThrow(new IOException("simulated log path failure")); BigQueryJdbcException thrown = Assertions.assertThrows( @@ -292,4 +304,175 @@ public void testConnect_ioExceptionThrowsInsteadOfReturningNull() { assertThat(thrown.getCause()).isInstanceOf(IOException.class); } } + + @Test + public void testMultiTenantLogPathAndLevelIsolationAndHandlerPreservation(@TempDir Path tempDir) + throws Exception { + BigQueryJdbcOpenTelemetry.ensureGlobalHandlerAttached(); + Path tenantADir = tempDir.resolve("tenant_a"); + Path tenantBDir = tempDir.resolve("tenant_b"); + Path tenantCDir = tempDir.resolve("tenant_c_off"); + + String tenantAUrl = + getBaseUri(2, "proj-a") + .append("OAuthAccessToken", "token-a-secret") + .append("LogLevel", 7) + .append("LogPath", tenantADir.toString()) + .toString(); + + String tenantBBaseUrl = + getBaseUri() + .append("ProjectId", "proj-b") + .append("LogLevel", 3) + .append("LogPath", tenantBDir.toString()) + .toString(); + Properties tenantBProps = new Properties(); + tenantBProps.setProperty("OAuthType", "2"); + tenantBProps.setProperty("OAuthAccessToken", "victim-tenant-b-secret-token"); + + String tenantCOffUrl = + getBaseUri(2, "proj-c") + .append("OAuthAccessToken", "token-c-secret") + .append("LogLevel", 0) + .append("LogPath", tenantCDir.toString()) + .toString(); + + Logger rootLogger = BigQueryJdbcRootLogger.getRootLogger(); + // Temporarily detach the base test's ALL capture handler to verify production root-level + // stepping across staggered connection closes, plus an external WARNING handler floor. + rootLogger.removeHandler(this.handler); + Handler externalWarningHandler = + new Handler() { + @Override + public void publish(LogRecord record) {} + + @Override + public void flush() {} + + @Override + public void close() {} + }; + try { + rootLogger.setLevel(Level.OFF); + Connection connA = bigQueryDriver.connect(tenantAUrl, new Properties()); + Connection connB = bigQueryDriver.connect(tenantBBaseUrl, tenantBProps); + Connection connC = bigQueryDriver.connect(tenantCOffUrl, new Properties()); + try { + assertThat(rootLogger.getLevel()).isEqualTo(Level.FINEST); + assertThat(Files.exists(tenantCDir)).isFalse(); + List rootHandlers = Arrays.asList(rootLogger.getHandlers()); + assertThat(rootHandlers.stream().anyMatch(h -> h instanceof OpenTelemetryJulHandler)) + .isTrue(); + + // Closing LogLevel=0 Tenant C must leave Tenant A at FINEST and Tenant B at INFO + connC.close(); + assertThat(rootLogger.getLevel()).isEqualTo(Level.FINEST); + + Assertions.assertThrows( + SQLException.class, + () -> + connA.createStatement( + ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE)); + + // Closing LogLevel=7 Tenant A steps root level up to Tenant B's INFO (not stuck at FINEST) + connA.close(); + assertThat(rootLogger.getLevel()).isEqualTo(Level.INFO); + + Assertions.assertThrows( + SQLException.class, + () -> + connB.createStatement( + ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE)); + + // Closing Tenant B steps root level all the way back to OFF + connB.close(); + assertThat(rootLogger.getLevel()).isEqualTo(Level.OFF); + + // Verify external handler floor is preserved (not ratcheted to FINEST) after FINEST closes + rootLogger.addHandler(externalWarningHandler); + rootLogger.setLevel(Level.WARNING); + try (Connection tempFinest = bigQueryDriver.connect(tenantAUrl, new Properties())) { + assertThat(rootLogger.getLevel()).isEqualTo(Level.FINEST); + } + assertThat(rootLogger.getLevel()).isEqualTo(Level.WARNING); + } finally { + rootLogger.removeHandler(externalWarningHandler); + connC.close(); + connB.close(); + connA.close(); + } + } finally { + rootLogger.addHandler(this.handler); + rootLogger.setLevel(Level.ALL); + } + + String tenantALogs = readAllLogFiles(tenantADir); + String tenantBLogs = readAllLogFiles(tenantBDir); + + // Tenant A gets FINEST/FINER + INFO logs for proj-a only; never sees Tenant B's secrets or logs + assertThat(tenantALogs).contains("++entry++"); + assertThat(tenantALogs).doesNotContain("victim-tenant-b-secret-token"); + assertThat(tenantALogs).doesNotContain("proj-b"); + + // Tenant B (LogLevel=3 INFO) gets INFO/SEVERE logs only (no FINER ++entry++) and masks secrets + assertThat(tenantBLogs).contains("Driver info"); + assertThat(tenantBLogs).doesNotContain("++entry++"); + assertThat(tenantBLogs).doesNotContain("victim-tenant-b-secret-token"); + assertThat(tenantBLogs).doesNotContain("proj-a"); + } + + @Test + public void testAllowUrlLogPathFalseBlocksUrlAndDefaultLogCreation(@TempDir Path tempDir) + throws Exception { + Path blockedDir = tempDir.resolve("blocked_url_dir"); + String propName = BigQueryJdbcUrlUtility.ALLOW_URL_LOG_PATH_SYSTEM_PROPERTY; + String prev = System.getProperty(propName); + System.setProperty(propName, "false"); + try { + String url = + getUriOAuthToken() + .append("ProjectId", "proj-locked") + .append("LogLevel", 7) + .append("LogPath", blockedDir.toString()) + .toString(); + try (Connection conn = bigQueryDriver.connect(url, new Properties())) { + assertThat(conn.isClosed()).isFalse(); + } + assertThat(Files.exists(blockedDir)).isFalse(); + assertThat(assertLogContains("Ignoring URL/Properties LogPath")).isTrue(); + + // Also verify that omitting LogPath when allowUrlLogPath=false does NOT fall back to CWD + Path cwd = Paths.get("").toAbsolutePath(); + long cwdLogsBefore; + try (Stream s = Files.list(cwd)) { + cwdLogsBefore = s.filter(p -> p.getFileName().toString().startsWith("BQ-JDBC-")).count(); + } + String noPathUrl = + getUriOAuthToken().append("ProjectId", "proj-no-cwd").append("LogLevel", 7).toString(); + try (Connection conn = bigQueryDriver.connect(noPathUrl, new Properties())) { + assertThat(conn.isClosed()).isFalse(); + } + try (Stream s = Files.list(cwd)) { + long cwdLogsAfter = + s.filter(p -> p.getFileName().toString().startsWith("BQ-JDBC-")).count(); + assertThat(cwdLogsAfter).isEqualTo(cwdLogsBefore); + } + } finally { + if (prev == null) { + System.clearProperty(propName); + } else { + System.setProperty(propName, prev); + } + } + } + + private static String readAllLogFiles(Path dir) throws IOException { + StringBuilder sb = new StringBuilder(); + try (Stream files = Files.list(dir)) { + for (Path p : files.collect(Collectors.toList())) { + sb.append(new String(Files.readAllBytes(p), StandardCharsets.UTF_8)); + } + } + return sb.toString(); + } } diff --git a/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcLoggingBaseTest.java b/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcLoggingBaseTest.java index 6ed3231eed15..5db138b280f7 100644 --- a/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcLoggingBaseTest.java +++ b/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcLoggingBaseTest.java @@ -27,7 +27,7 @@ public abstract class BigQueryJdbcLoggingBaseTest extends BigQueryJdbcBaseTest { protected List capturedLogs = new ArrayList<>(); - private Handler handler; + protected Handler handler; private Logger logger; private long threadId; private java.util.logging.Level originalLevel; @@ -63,11 +63,7 @@ public void tearDownLogValidator() { logger.removeHandler(handler); logger.setLevel(originalLevel); } - try { - BigQueryJdbcRootLogger.setLevel(java.util.logging.Level.OFF, null); - } catch (Exception e) { - // Ignore - } + BigQueryJdbcRootLogger.resetForTesting(); } protected boolean assertLogContains(String snippet) { diff --git a/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcMdcTest.java b/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcMdcTest.java index 1194f4e580b4..abc03ce2db36 100644 --- a/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcMdcTest.java +++ b/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcMdcTest.java @@ -138,6 +138,23 @@ public void testMdcCloseableClearsContext() { assertNull(BigQueryJdbcMdc.getConnectionId()); } + @Test + public void testNestedRegisterInstanceRestoresEnclosingContext() { + try (BigQueryJdbcMdc.MdcCloseable outer = BigQueryJdbcMdc.registerInstance("OuterConnection")) { + assertEquals("OuterConnection", BigQueryJdbcMdc.getConnectionId()); + try (BigQueryJdbcMdc.MdcCloseable inner = + BigQueryJdbcMdc.registerInstance("InnerConnection")) { + assertEquals("InnerConnection", BigQueryJdbcMdc.getConnectionId()); + try (BigQueryJdbcMdc.MdcCloseable noopNull = BigQueryJdbcMdc.registerInstance(null)) { + assertEquals("InnerConnection", BigQueryJdbcMdc.getConnectionId()); + } + assertEquals("InnerConnection", BigQueryJdbcMdc.getConnectionId()); + } + assertEquals("OuterConnection", BigQueryJdbcMdc.getConnectionId()); + } + assertNull(BigQueryJdbcMdc.getConnectionId()); + } + @Test public void testExecutorPropagatesMdc() throws Exception { BigQueryJdbcMdc.registerInstance("JdbcConnection-Executor-Test"); diff --git a/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcUrlUtilityTest.java b/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcUrlUtilityTest.java index daf938657196..e1ca60dc1c36 100644 --- a/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcUrlUtilityTest.java +++ b/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcUrlUtilityTest.java @@ -31,6 +31,8 @@ import java.util.Map; import java.util.Properties; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; public class BigQueryJdbcUrlUtilityTest extends BigQueryJdbcLoggingBaseTest { @@ -413,4 +415,59 @@ public void testEnableGraphMetadataProperties() { assertThat(defaultDs.getEnableGraphMetadata()) .isEqualTo(BigQueryJdbcUrlUtility.DEFAULT_ENABLE_GRAPH_METADATA_VALUE); } + + @ParameterizedTest + @ValueSource( + strings = { + "OAuthAccessToken", + "OAuthRefreshToken", + "OAuthPvtKey", + "OAuthClientSecret", + "OAuthP12Password", + "ProxyPwd", + "ProxyUid", + "SSLTrustStorePwd", + "gcpTelemetryCredentials", + "BYOID_CredentialSource", + "CustomSecretProperty" + }) + public void testAppendPropertiesToURL_masksSensitivePropertiesAtFinest(String secretKey) { + capturedLogs.clear(); + String baseUrl = "bigquery://https://www.googleapis.com/bigquery/v2:443"; + Properties props = new Properties(); + String rawSecret = "super-secret-value-98765"; + props.setProperty(secretKey, rawSecret); + props.setProperty("ProjectId", "visible-project"); + + String updated = BigQueryJdbcUrlUtility.appendPropertiesToURL(baseUrl, "TestCaller", props); + + assertThat(updated).contains(secretKey + "=" + rawSecret); + assertThat(assertLogContains("Appending " + secretKey + " with value ***** to URL")).isTrue(); + assertThat(assertLogContains("Appending ProjectId with value visible-project to URL")).isTrue(); + assertThat(assertLogContains(rawSecret)).isFalse(); + } + + @Test + public void testAppendPropertiesToURL_handlesNullAndNonStringProperties() { + String baseUrl = "bigquery://https://www.googleapis.com/bigquery/v2:443"; + assertThat(BigQueryJdbcUrlUtility.appendPropertiesToURL(baseUrl, "Caller", null)) + .isEqualTo(baseUrl); + assertThat(BigQueryJdbcUrlUtility.appendPropertiesToURL(baseUrl, "Caller", new Properties())) + .isEqualTo(baseUrl); + + Properties nonStringProps = new Properties(); + nonStringProps.put("MaxResults", 500); + nonStringProps.put("OAuthAccessToken", 123456); + capturedLogs.clear(); + + String updated = + BigQueryJdbcUrlUtility.appendPropertiesToURL(baseUrl, "Caller", nonStringProps); + assertThat(updated).contains("MaxResults=500"); + assertThat(updated).contains("OAuthAccessToken=123456"); + assertThat(assertLogContains("Appending MaxResults with value 500 to URL")).isTrue(); + assertThat(assertLogContains("Appending OAuthAccessToken with value ***** to URL")).isTrue(); + assertThat(assertLogContains("123456")).isFalse(); + assertThat(BigQueryConnection.maskPropertyValue(null, "secret")).isEqualTo("*****"); + assertThat(BigQueryConnection.maskPropertyValue("ProjectId", null)).isNull(); + } } diff --git a/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/PerConnectionFileHandlerTest.java b/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/PerConnectionFileHandlerTest.java index c0362daaa677..4977d19b74bf 100644 --- a/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/PerConnectionFileHandlerTest.java +++ b/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/PerConnectionFileHandlerTest.java @@ -484,9 +484,10 @@ public void testPostCloseResultSetAndStringParamsDoNotResurrectHandlers() throws try { String connId = "dead-conn-uuid"; - ConnectionLogContext activeCtx = BigQueryJdbcRootLogger.registerConnection(connId); + ConnectionLogContext activeCtx = + BigQueryJdbcRootLogger.registerConnection(connId, Level.FINEST, null); assertNotNull(activeCtx); - assertEquals(ConnectionLogContext.ALL_VALUE, activeCtx.levelValue()); + assertEquals(Level.FINEST.intValue(), activeCtx.levelValue()); finestHandler.registerConnection(connId); // Construct ResultSet and child Struct logger WHILE connection is active (covers active != @@ -565,4 +566,21 @@ public void testFailedConnectionConstructorCleansUpActiveRegistration() throws I BigQueryJdbcRootLogger.setLevel(Level.OFF, null); } } + + @Test + public void testPersistentHandlerDoesNotOpenImplicitSlotsForOffConnections() throws IOException { + PerConnectionFileHandler persistent = new PerConnectionFileHandler(); + String offConnId = "explicit-off-conn"; + try { + BigQueryJdbcRootLogger.registerConnection(offConnId, Level.OFF, null); + try (BigQueryJdbcMdc.MdcCloseable mdc = BigQueryJdbcMdc.registerInstance(offConnId)) { + persistent.publish(new LogRecord(Level.SEVERE, "Should not open implicit slot")); + } + persistent.flush(); + assertTrue(BigQueryJdbcRootLogger.isConnectionActive(offConnId)); + } finally { + BigQueryJdbcRootLogger.closeConnectionHandler(offConnId); + persistent.close(); + } + } }