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 c72bae6f8a58..b88d17689ac6 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 @@ -291,8 +291,8 @@ static String maskPropertyValue(String key, Object value) { boolean initialized = false; ExecutorService createdQueryExecutor = null; ExecutorService createdMetadataExecutor = null; - try (BigQueryJdbcMdc.MdcCloseable mdc = BigQueryJdbcMdc.registerInstance(this.connectionId)) { - BigQueryJdbcRootLogger.registerConnection(this.connectionId); + try (BigQueryJdbcMdc.MdcCloseable mdc = + BigQueryJdbcMdc.registerAndBindConnection(this.connectionId)) { this.connectionUrl = url; if (LOG.isLoggable(Level.CONFIG)) { Properties connectionProps = ds.createProperties(); 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 f16572ea5a87..cec886b05209 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 @@ -135,7 +135,8 @@ public Connection connect(String url, Properties info) throws SQLException { String connectionId = UUID.randomUUID().toString(); BigQueryConnection connection = null; boolean connectionReturned = false; - try (BigQueryJdbcMdc.MdcCloseable mdc = BigQueryJdbcMdc.registerInstance(connectionId)) { + try (BigQueryJdbcMdc.MdcCloseable mdc = + BigQueryJdbcMdc.registerAndBindConnection(connectionId)) { Properties connectInfo = info == null ? new Properties() : (Properties) info.clone(); Object customOpenTelemetryObj = connectInfo.remove("customOpenTelemetry"); diff --git a/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcContextProxy.java b/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcContextProxy.java index fc724e53e543..5ea66f073895 100644 --- a/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcContextProxy.java +++ b/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcContextProxy.java @@ -35,11 +35,13 @@ class BigQueryJdbcContextProxy implements InvocationHandler { private final Object target; private final String connectionId; + private final ConnectionLogContext connectionContext; private final Class interfaceType; private BigQueryJdbcContextProxy(Object target, String connectionId, Class interfaceType) { this.target = target; this.connectionId = connectionId; + this.connectionContext = BigQueryJdbcRootLogger.resolveContext(connectionId); this.interfaceType = interfaceType; } @@ -132,7 +134,7 @@ public Object invoke(Object proxy, Method method, Object[] args) throws Throwabl } // Wrap execution in the context of the active connection for all non-bypassed methods - try (BigQueryJdbcMdc.MdcCloseable mdc = BigQueryJdbcMdc.registerInstance(connectionId)) { + try (BigQueryJdbcMdc.MdcCloseable mdc = BigQueryJdbcMdc.registerContext(connectionContext)) { boolean isFinerLoggable = LOG.isLoggable(Level.FINER); String targetClassName = null; if (isFinerLoggable) { @@ -173,7 +175,7 @@ public Object invoke(Object proxy, Method method, Object[] args) throws Throwabl // Unified Context Logger: Captures and logs every exception exactly once with the Connection // context - try (BigQueryJdbcMdc.MdcCloseable mdc = BigQueryJdbcMdc.registerInstance(connectionId)) { + try (BigQueryJdbcMdc.MdcCloseable mdc = BigQueryJdbcMdc.registerContext(connectionContext)) { String errMsg = cause.getMessage() != null ? cause.getMessage() : cause.toString(); LOG.severe("Exception occurred during " + methodName + ": " + errMsg, cause); } diff --git a/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcCustomLogger.java b/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcCustomLogger.java index ef67a9cc9719..84caae53e5c7 100644 --- a/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcCustomLogger.java +++ b/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcCustomLogger.java @@ -17,11 +17,13 @@ package com.google.cloud.bigquery.jdbc; import java.util.function.Supplier; +import java.util.logging.Handler; import java.util.logging.Level; import java.util.logging.LogRecord; import java.util.logging.Logger; public class BigQueryJdbcCustomLogger extends Logger { + private volatile boolean hasOwnHandlers; protected BigQueryJdbcCustomLogger(String name, String resourceBundleName) { super(name, resourceBundleName); @@ -32,6 +34,41 @@ public BigQueryJdbcCustomLogger(String name) { this(name, null); } + @Override + public synchronized void addHandler(Handler handler) throws SecurityException { + super.addHandler(handler); + this.hasOwnHandlers = getHandlers().length > 0; + } + + @Override + public synchronized void removeHandler(Handler handler) throws SecurityException { + super.removeHandler(handler); + this.hasOwnHandlers = getHandlers().length > 0; + } + + @Override + public boolean isLoggable(Level level) { + return isLoggableForContext(level, BigQueryJdbcMdc.getContext()); + } + + boolean isLoggableForContext(Level level, ConnectionLogContext ctx) { + if (level == null || !super.isLoggable(level)) { + return false; + } + if (this.hasOwnHandlers || BigQueryJdbcRootLogger.hasExternalHandler()) { + return true; + } + if (ctx != null) { + int rawThreshold = ctx.levelValue(); + if (rawThreshold == ConnectionLogContext.INHERIT_VALUE) { + return true; + } + int threshold = Math.min(rawThreshold, BigQueryJdbcRootLogger.explicitGlobalLevelValue()); + return threshold != ConnectionLogContext.OFF_VALUE && level.intValue() >= threshold; + } + return true; + } + private void logWithCaller(Level level, Supplier msgSupplier) { logWithCaller(level, null, msgSupplier); } 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 0e76c5ec1494..e3ba843c8ec0 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 @@ -33,37 +33,60 @@ class BigQueryJdbcMdc { private static final BigQueryJdbcCustomLogger LOG = new BigQueryJdbcCustomLogger(BigQueryJdbcMdc.class.getName()); - private static final InheritableThreadLocal currentConnectionId = + private static final InheritableThreadLocal currentContext = new InheritableThreadLocal<>(); /** - * Sets the current connection context on the executing thread and restores any enclosing context - * upon close. + * Binds the given {@link ConnectionLogContext} on the executing thread and restores any enclosing + * context upon close. */ - static MdcCloseable registerInstance(String connectionId) { - if (connectionId == null) { + static MdcCloseable registerContext(ConnectionLogContext context) { + if (context == null) { return () -> {}; } - String previous = currentConnectionId.get(); - currentConnectionId.set(connectionId); + ConnectionLogContext previous = currentContext.get(); + currentContext.set(context); return () -> { if (previous != null) { - currentConnectionId.set(previous); + currentContext.set(previous); } else { clear(); } }; } + /** + * Sets the current connection context on the executing thread and restores any enclosing context + * upon close. + */ + static MdcCloseable registerInstance(String connectionId) { + if (connectionId == null) { + return () -> {}; + } + return registerContext(BigQueryJdbcRootLogger.resolveContext(connectionId)); + } + + static MdcCloseable registerAndBindConnection(String connectionId) { + if (connectionId == null) { + return () -> {}; + } + return registerContext(BigQueryJdbcRootLogger.registerConnection(connectionId)); + } + + static ConnectionLogContext getContext() { + return currentContext.get(); + } + /** * Returns the connection ID carried by any registered active connection on the current thread. */ static String getConnectionId() { - return currentConnectionId.get(); + ConnectionLogContext ctx = currentContext.get(); + return ctx != null ? ctx.connectionId() : null; } static void clear() { - currentConnectionId.remove(); + currentContext.remove(); } /** @@ -190,18 +213,18 @@ public void execute(Runnable command) { @Override protected RunnableFuture newTaskFor(Runnable runnable, T value) { - return new MdcFutureTask<>(runnable, value, getConnectionId()); + return new MdcFutureTask<>(runnable, value, getContext()); } @Override protected RunnableFuture newTaskFor(Callable callable) { - return new MdcFutureTask<>(callable, getConnectionId()); + return new MdcFutureTask<>(callable, getContext()); } private static Runnable wrap(Runnable runnable) { - String connectionId = getConnectionId(); + ConnectionLogContext context = getContext(); return () -> { - try (MdcCloseable mdc = registerInstance(connectionId)) { + try (MdcCloseable mdc = registerContext(context)) { runnable.run(); } }; @@ -209,21 +232,21 @@ private static Runnable wrap(Runnable runnable) { } private static class MdcFutureTask extends FutureTask { - private final String connectionId; + private final ConnectionLogContext context; - public MdcFutureTask(Runnable runnable, V result, String connectionId) { + MdcFutureTask(Runnable runnable, V result, ConnectionLogContext context) { super(runnable, result); - this.connectionId = connectionId; + this.context = context; } - public MdcFutureTask(Callable callable, String connectionId) { + MdcFutureTask(Callable callable, ConnectionLogContext context) { super(callable); - this.connectionId = connectionId; + this.context = context; } @Override public void run() { - try (MdcCloseable mdc = registerInstance(connectionId)) { + try (MdcCloseable mdc = registerContext(context)) { super.run(); } } diff --git a/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcResultSetLogger.java b/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcResultSetLogger.java index 6ead87ad49a2..c9979da2af9a 100644 --- a/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcResultSetLogger.java +++ b/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcResultSetLogger.java @@ -75,12 +75,7 @@ public static BigQueryJdbcResultSetLogger getLogger(Class clazz, String conne if (connectionId == null || connectionId.isEmpty()) { return getLogger(clazz, (ConnectionLogContext) null); } - ConnectionLogContext active = BigQueryJdbcRootLogger.findActiveContext(connectionId); - ConnectionLogContext context = - active != null - ? active - : new ConnectionLogContext(connectionId, ConnectionLogContext.ALL_VALUE); - return getLogger(clazz, context); + return getLogger(clazz, BigQueryJdbcRootLogger.resolveContext(connectionId)); } static BigQueryJdbcResultSetLogger getLogger( @@ -105,7 +100,12 @@ BigQueryJdbcCustomLogger delegate() { } public boolean isLoggable(Level level) { - return delegate.isLoggable(level); + if (level == null) { + return false; + } + ConnectionLogContext ctx = + connectionContext != null ? connectionContext : BigQueryJdbcMdc.getContext(); + return delegate.isLoggableForContext(level, ctx); } public BigQueryJdbcResultSetLogger getArrowStructLogger() { @@ -143,6 +143,9 @@ public BigQueryJdbcResultSetLogger getJsonArrayLogger() { * BigQueryJdbcCustomLogger.BigQueryJdbcLogRecord} to infer them lazily. */ public void log(LogRecord record) { + if (record == null || !isLoggable(record.getLevel())) { + return; + } if (connectionContext != null) { Object[] existingParams = record.getParameters(); if (existingParams == null || existingParams.length == 0) { @@ -153,12 +156,20 @@ public void log(LogRecord record) { System.arraycopy(existingParams, 0, newParams, 1, existingParams.length); record.setParameters(newParams); } + ConnectionLogContext threadContext = BigQueryJdbcMdc.getContext(); + if (threadContext != null && threadContext != connectionContext) { + try (BigQueryJdbcMdc.MdcCloseable ignored = + BigQueryJdbcMdc.registerContext(connectionContext)) { + delegate.log(record); + } + return; + } } delegate.log(record); } private void logTrace(Level level, String methodName, String msg) { - if (!delegate.isLoggable(level)) { + if (!isLoggable(level)) { return; } LogRecord record = new LogRecord(level, msg); @@ -168,15 +179,18 @@ private void logTrace(Level level, String methodName, String msg) { } private void logTrace(Level level, String methodName, Supplier msgSupplier) { - if (!delegate.isLoggable(level)) { + if (!isLoggable(level)) { return; } - logTrace(level, methodName, msgSupplier.get()); + LogRecord record = new LogRecord(level, msgSupplier.get()); + record.setSourceClassName(targetClassName); + record.setSourceMethodName(methodName); + log(record); } /** Cold path: builds a record whose caller is inferred lazily by the formatter. */ private void logWithCaller(Level level, Throwable thrown, String msg) { - if (!delegate.isLoggable(level)) { + if (!isLoggable(level)) { return; } LogRecord record = new BigQueryJdbcCustomLogger.BigQueryJdbcLogRecord(level, msg); @@ -244,7 +258,7 @@ public void fine(Supplier msgSupplier) { } public void warning(String format, Object... args) { - if (!delegate.isLoggable(Level.WARNING)) { + if (!isLoggable(Level.WARNING)) { return; } String message = (args == null || args.length == 0) ? format : String.format(format, args); 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 e63be3d77e3a..2204f8dc83a5 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 @@ -30,30 +30,34 @@ import java.util.logging.Formatter; import java.util.logging.Handler; import java.util.logging.Level; +import java.util.logging.LogManager; import java.util.logging.LogRecord; import java.util.logging.Logger; /** This class is used to log messages from the BigQuery JDBC Driver. */ class BigQueryJdbcRootLogger { - /** - * Note: Each connection will have its own file handler with the level and logPath specified in - * the connection properties. But the logs will be driver logs and not connection specific. - */ - private static final Logger logger = Logger.getLogger("com.google.cloud.bigquery"); - - private static final Logger storageLogger = Logger.getLogger("com.google.cloud.bigquery.storage"); private static final boolean isTest = Boolean.getBoolean("JDBC_TESTS"); private static final ConcurrentHashMap ACTIVE_CONNECTIONS = new ConcurrentHashMap<>(); private static ConsoleHandler testConsoleHandler = null; + private static volatile boolean externalHandlerAttached; private static volatile PerConnectionFileHandler persistentFileHandler = null; private static volatile Handler fileHandler = null; private static volatile Level explicitGlobalLevel = Level.OFF; + private static volatile int explicitGlobalLevelValue = ConnectionLogContext.OFF_VALUE; private static Level lastDriverAppliedLevel = null; private static Level externalFloorLevel = null; + /** + * Note: Each connection will have its own file handler with the level and logPath specified in + * the connection properties. But the logs will be driver logs and not connection specific. + */ + private static final Logger logger = createRootLogger(); + + private static final Logger storageLogger = Logger.getLogger("com.google.cloud.bigquery.storage"); + static final String PROCESS_ID = ManagementFactory.getRuntimeMXBean().getName().split("@")[0]; private static final DateTimeFormatter DATE_FORMATTER = @@ -167,6 +171,67 @@ public String format(LogRecord record) { }; } + private static Logger createRootLogger() { + LogManager manager = LogManager.getLogManager(); + Logger existing = manager.getLogger("com.google.cloud.bigquery"); + if (existing != null) { + return existing; + } + RootDriverLogger customRoot = new RootDriverLogger("com.google.cloud.bigquery"); + if (manager.addLogger(customRoot)) { + return customRoot; + } + return Logger.getLogger("com.google.cloud.bigquery"); + } + + private static final class RootDriverLogger extends Logger { + RootDriverLogger(String name) { + super(name, null); + super.setUseParentHandlers(false); + } + + @Override + public synchronized void addHandler(Handler handler) throws SecurityException { + super.addHandler(handler); + externalHandlerAttached = scanForExternalHandler(this); + } + + @Override + public synchronized void removeHandler(Handler handler) throws SecurityException { + super.removeHandler(handler); + externalHandlerAttached = scanForExternalHandler(this); + } + + @Override + public synchronized void setUseParentHandlers(boolean useParentHandlers) { + super.setUseParentHandlers(useParentHandlers); + externalHandlerAttached = scanForExternalHandler(this); + } + } + + static boolean scanForExternalHandler(Logger target) { + if (target.getUseParentHandlers()) { + return true; + } + for (Handler h : target.getHandlers()) { + if (!isDriverOwnedHandler(h)) { + return true; + } + } + return false; + } + + static boolean hasExternalHandler() { + if (logger instanceof RootDriverLogger) { + return externalHandlerAttached; + } + return scanForExternalHandler(logger); + } + + static int explicitGlobalLevelValue() { + return explicitGlobalLevelValue; + } + public static Logger getRootLogger() { return logger; } @@ -184,7 +249,6 @@ private static synchronized PerConnectionFileHandler ensurePersistentFileHandler } if (!attached) { logger.addHandler(persistentFileHandler); - logger.setUseParentHandlers(false); } return persistentFileHandler; } @@ -195,18 +259,9 @@ private static boolean isDriverOwnedHandler(Handler handler) { || (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 (hasExternalHandler()) { if (current != lastDriverAppliedLevel) { externalFloorLevel = current; } @@ -228,7 +283,10 @@ private static synchronized void refreshEffectiveRootLevel() { } } for (ConnectionLogContext ctx : ACTIVE_CONNECTIONS.values()) { - targetValue = Math.min(targetValue, ctx.levelValue()); + int ctxLevel = ctx.levelValue(); + if (ctxLevel != ConnectionLogContext.INHERIT_VALUE) { + targetValue = Math.min(targetValue, ctxLevel); + } } if (externalFloorLevel != null) { targetValue = Math.min(targetValue, externalFloorLevel.intValue()); @@ -269,6 +327,7 @@ private static Level toJulLevel(int levelValue) { public static synchronized void setLevel(Level level, String logPath) throws IOException { Level effective = level != null ? level : Level.OFF; explicitGlobalLevel = effective; + explicitGlobalLevelValue = effective.intValue(); if (effective != Level.OFF) { if (logPath != null) { setPath(logPath, effective); @@ -298,7 +357,6 @@ static synchronized void setPath(String logPath, Level level) { fileHandler = new PerConnectionFileHandler(logPath, level); fileHandler.setLevel(level); logger.addHandler(fileHandler); - logger.setUseParentHandlers(false); } catch (Exception ex) { logger.warning("Log File warning : " + ex); @@ -311,7 +369,7 @@ static ConnectionLogContext registerConnection(String connectionId) { } ConnectionLogContext context = ACTIVE_CONNECTIONS.computeIfAbsent( - connectionId, id -> new ConnectionLogContext(id, ConnectionLogContext.OFF_VALUE)); + connectionId, id -> new ConnectionLogContext(id, ConnectionLogContext.INHERIT_VALUE)); Handler currentHandler = fileHandler; if (currentHandler instanceof PerConnectionFileHandler) { ((PerConnectionFileHandler) currentHandler).registerConnection(connectionId); @@ -354,11 +412,14 @@ static synchronized ConnectionLogContext registerConnection( } } - static ConnectionLogContext findActiveContext(String connectionId) { + static ConnectionLogContext resolveContext(String connectionId) { if (connectionId == null || connectionId.isEmpty()) { return null; } - return ACTIVE_CONNECTIONS.get(connectionId); + ConnectionLogContext active = ACTIVE_CONNECTIONS.get(connectionId); + return active != null + ? active + : new ConnectionLogContext(connectionId, ConnectionLogContext.INHERIT_VALUE); } static boolean isConnectionActive(String connectionId) { @@ -403,6 +464,7 @@ static synchronized void resetForTesting() { fileHandler = null; } explicitGlobalLevel = Level.OFF; + explicitGlobalLevelValue = ConnectionLogContext.OFF_VALUE; refreshEffectiveRootLevel(); } } diff --git a/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/ConnectionLogContext.java b/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/ConnectionLogContext.java index 073b2333a72b..1c2a1e44482e 100644 --- a/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/ConnectionLogContext.java +++ b/java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/ConnectionLogContext.java @@ -27,6 +27,7 @@ final class ConnectionLogContext { static final int OFF_VALUE = Level.OFF.intValue(); static final int ALL_VALUE = Level.ALL.intValue(); + static final int INHERIT_VALUE = ALL_VALUE + 1; private final String connectionId; private volatile int levelValue; diff --git a/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcCustomLoggerTest.java b/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcCustomLoggerTest.java index abc2eeb50591..6a668167371d 100644 --- a/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcCustomLoggerTest.java +++ b/java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcCustomLoggerTest.java @@ -17,6 +17,7 @@ package com.google.cloud.bigquery.jdbc; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotSame; import static org.junit.jupiter.api.Assertions.assertSame; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -29,17 +30,27 @@ import com.google.cloud.bigquery.FieldValue.Attribute; import com.google.cloud.bigquery.FieldValueList; import com.google.cloud.bigquery.LegacySQLTypeName; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; import java.nio.file.Path; import java.util.ArrayList; +import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Map.Entry; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicInteger; import java.util.logging.Handler; import java.util.logging.Level; import java.util.logging.LogRecord; import java.util.logging.Logger; +import java.util.stream.Stream; import org.apache.arrow.vector.util.JsonStringArrayList; import org.apache.arrow.vector.util.JsonStringHashMap; import org.junit.jupiter.api.AfterEach; @@ -215,6 +226,7 @@ public void testResultSetLoggerTrace() { assertEquals("Hello finest trace message", record.getMessage()); } finally { rsLogger.delegate().removeHandler(rsHandler); + rsLogger.delegate().setLevel(null); } } @@ -250,6 +262,7 @@ public void testResultSetLoggerStandardMethods() { assertEquals("Fine msg", r3.getMessage()); } finally { rsLogger.delegate().removeHandler(rsHandler); + rsLogger.delegate().setLevel(null); } } @@ -287,6 +300,7 @@ public void testResultSetLoggerSupplierMethods() { assertEquals("Lazy finest RS message", record.getMessage()); } finally { rsLogger.delegate().removeHandler(rsHandler); + rsLogger.delegate().setLevel(null); } } @@ -325,6 +339,7 @@ public void testResultSetLoggerSupplierTraceMethods() { assertEquals("Lazy finest RS trace message", record.getMessage()); } finally { rsLogger.delegate().removeHandler(rsHandler); + rsLogger.delegate().setLevel(null); } } @@ -377,6 +392,7 @@ public void testResultSetLoggerParameterPreservation() { assertEquals("job-999", params[1]); } finally { rsLogger.delegate().removeHandler(rsHandler); + rsLogger.delegate().setLevel(null); } } @@ -738,6 +754,293 @@ public void testConnectionScopedResultSetLoggersDoNotRegisterChildLoggers() "Connection-scoped result-set loggers must not register child loggers on the driver root"); } + @Test + public void testGate1ShortCircuitsDisabledAndHigherThresholdConnectionsWhileFinestIsActive( + @TempDir Path tempDir) throws Exception { + Logger rootLogger = BigQueryJdbcRootLogger.getRootLogger(); + rootLogger.removeHandler(this.handler); + logger.removeHandler(testHandler); + + String finestConn = "conn-gate1-finest"; + String infoConn = "conn-gate1-info"; + String offConn = "conn-gate1-off"; + + try { + BigQueryJdbcRootLogger.registerConnection( + finestConn, Level.FINEST, tempDir.resolve("finest").toString()); + BigQueryJdbcRootLogger.registerConnection( + infoConn, Level.INFO, tempDir.resolve("info").toString()); + BigQueryJdbcRootLogger.registerConnection(offConn, Level.OFF, null); + + assertFalse(BigQueryJdbcRootLogger.hasExternalHandler()); + assertEquals(Level.FINEST, rootLogger.getLevel()); + assertFalse(logger.isLoggable(null)); + + AtomicInteger supplierEvaluations = new AtomicInteger(); + BigQueryJdbcResultSetLogger globalRsLogger = + BigQueryJdbcResultSetLogger.getLogger(BigQueryResultSetMetadata.class); + + // 1. CustomLogger + Global ResultSetLogger + MDC path + try (BigQueryJdbcMdc.MdcCloseable offMdc = BigQueryJdbcMdc.registerInstance(offConn)) { + assertFalse(logger.isLoggable(Level.SEVERE)); + assertFalse(globalRsLogger.isLoggable(Level.FINEST)); + logger.fine( + () -> { + supplierEvaluations.incrementAndGet(); + return "Should not evaluate on OFF connection"; + }); + globalRsLogger.finestTrace( + "getColumnCount", + () -> { + supplierEvaluations.incrementAndGet(); + return "Should not evaluate on global RS facade under OFF MDC"; + }); + } + try (BigQueryJdbcMdc.MdcCloseable infoMdc = BigQueryJdbcMdc.registerInstance(infoConn)) { + assertFalse(logger.isLoggable(Level.FINE)); + assertFalse(globalRsLogger.isLoggable(Level.FINE)); + assertTrue(logger.isLoggable(Level.INFO)); + assertTrue(globalRsLogger.isLoggable(Level.INFO)); + logger.fine( + () -> { + supplierEvaluations.incrementAndGet(); + return "Should not evaluate FINE on INFO connection"; + }); + } + assertEquals(0, supplierEvaluations.get()); + + // 2. Connection-scoped ResultSetLogger + child Struct/Array loggers + BigQueryJdbcResultSetLogger offRsLogger = + BigQueryJdbcResultSetLogger.getLogger(BigQueryBaseResultSet.class, offConn); + BigQueryJdbcResultSetLogger offStructLogger = offRsLogger.getArrowStructLogger(); + BigQueryJdbcResultSetLogger infoRsLogger = + BigQueryJdbcResultSetLogger.getLogger(BigQueryBaseResultSet.class, infoConn); + BigQueryJdbcResultSetLogger finestRsLogger = + BigQueryJdbcResultSetLogger.getLogger(BigQueryBaseResultSet.class, finestConn); + + assertFalse(offRsLogger.isLoggable(null)); + assertFalse(offRsLogger.isLoggable(Level.FINEST)); + assertFalse(offStructLogger.isLoggable(Level.FINEST)); + assertFalse(infoRsLogger.isLoggable(Level.FINEST)); + assertTrue(infoRsLogger.isLoggable(Level.INFO)); + assertTrue(finestRsLogger.isLoggable(Level.FINEST)); + + offRsLogger.finestTrace( + "getInt", + () -> { + supplierEvaluations.incrementAndGet(); + return "Skipped on OFF RS"; + }); + offStructLogger.finest( + () -> { + supplierEvaluations.incrementAndGet(); + return "Skipped on OFF Struct"; + }); + infoRsLogger.finestTrace( + "getString", + () -> { + supplierEvaluations.incrementAndGet(); + return "Skipped on INFO RS"; + }); + assertEquals(0, supplierEvaluations.get()); + + // 3. Closing FINEST connection leaves rootLogger at Level.INFO (from infoConn), so + // super.isLoggable(SEVERE/WARNING) is still true, yet finestRsLogger's flipped OFF_VALUE + // context short-circuits SEVERE and WARNING at Gate 1! + BigQueryJdbcRootLogger.closeConnectionHandler(finestConn); + assertEquals(Level.INFO, rootLogger.getLevel()); + assertNullSafeDelegateDefaultLevel(finestRsLogger); + assertFalse(finestRsLogger.isLoggable(Level.SEVERE)); + assertFalse(finestRsLogger.isLoggable(Level.WARNING)); + finestRsLogger.warning("Post-close warning %s", "skipped"); + assertEquals(0, supplierEvaluations.get()); + } finally { + BigQueryJdbcRootLogger.closeConnectionHandler(finestConn); + BigQueryJdbcRootLogger.closeConnectionHandler(infoConn); + BigQueryJdbcRootLogger.closeConnectionHandler(offConn); + restoreTestHandlers(rootLogger); + } + } + + @Test + public void testGate1NestedMdcIsolationWritesToResultSetLogAndRestoresMdc(@TempDir Path tempDir) + throws Exception { + Logger rootLogger = BigQueryJdbcRootLogger.getRootLogger(); + rootLogger.removeHandler(this.handler); + logger.removeHandler(testHandler); + + String finestConn = "conn-nested-finest"; + String offConn = "conn-nested-off"; + Path finestDir = tempDir.resolve("finest"); + Path offDir = tempDir.resolve("off"); + + try { + BigQueryJdbcRootLogger.registerConnection(finestConn, Level.FINEST, finestDir.toString()); + BigQueryJdbcRootLogger.registerConnection(offConn, Level.OFF, offDir.toString()); + + BigQueryJdbcResultSetLogger finestRsLogger = + BigQueryJdbcResultSetLogger.getLogger(BigQueryBaseResultSet.class, finestConn); + BigQueryJdbcResultSetLogger offRsLogger = + BigQueryJdbcResultSetLogger.getLogger(BigQueryBaseResultSet.class, offConn); + + // FINEST ResultSet nested inside an OFF MDC must actually write to finestDir and restore MDC + try (BigQueryJdbcMdc.MdcCloseable offMdc = BigQueryJdbcMdc.registerInstance(offConn)) { + finestRsLogger.finestTrace("getInt", () -> "Nested FINEST RS marker"); + assertEquals(offConn, BigQueryJdbcMdc.getConnectionId()); + } + + // OFF ResultSet nested inside a FINEST MDC must skip warning formatting, manual records, and + // null records without writing to finestDir or creating offDir + try (BigQueryJdbcMdc.MdcCloseable finestMdc = BigQueryJdbcMdc.registerInstance(finestConn)) { + offRsLogger.warning("Should not appear in finest log %s", "ever"); + offRsLogger.log(new LogRecord(Level.SEVERE, "Manual OFF record skipped")); + offRsLogger.log(null); + assertEquals(finestConn, BigQueryJdbcMdc.getConnectionId()); + } + + BigQueryJdbcRootLogger.closeConnectionHandler(finestConn); + assertFalse(Files.exists(offDir)); + + List finestFiles; + try (Stream s = Files.list(finestDir)) { + finestFiles = Arrays.asList(s.toArray(Path[]::new)); + } + assertEquals(1, finestFiles.size()); + String content = new String(Files.readAllBytes(finestFiles.get(0)), StandardCharsets.UTF_8); + assertTrue(content.contains("Nested FINEST RS marker")); + assertTrue(content.contains("[" + finestConn + "]")); + assertFalse(content.contains("Should not appear in finest log")); + assertFalse(content.contains("Manual OFF record skipped")); + } finally { + BigQueryJdbcRootLogger.closeConnectionHandler(finestConn); + BigQueryJdbcRootLogger.closeConnectionHandler(offConn); + restoreTestHandlers(rootLogger); + } + } + + @Test + public void testGate1OverridesAsyncPropagationUseParentHandlersAndFallbackScan( + @TempDir Path tempDir) throws Exception { + Logger rootLogger = BigQueryJdbcRootLogger.getRootLogger(); + rootLogger.removeHandler(this.handler); + logger.removeHandler(testHandler); + + String finestConn = "conn-branch-finest"; + String offConn = "conn-branch-off"; + String inheritConn = "conn-branch-inherit"; + + try { + BigQueryJdbcRootLogger.registerConnection( + finestConn, Level.FINEST, tempDir.resolve("finest").toString()); + BigQueryJdbcRootLogger.registerConnection(offConn, Level.OFF, null); + BigQueryJdbcResultSetLogger offRsLogger = + BigQueryJdbcResultSetLogger.getLogger(BigQueryBaseResultSet.class, offConn); + + // 1. Unattributed (ctx == null) and 1-arg INHERIT_VALUE connections defer to rootLogger + BigQueryJdbcMdc.clear(); + assertTrue(logger.isLoggable(Level.FINEST)); + try (BigQueryJdbcMdc.MdcCloseable noopMdc = BigQueryJdbcMdc.registerAndBindConnection(null)) { + assertEquals(null, BigQueryJdbcMdc.getConnectionId()); + } + try (BigQueryJdbcMdc.MdcCloseable inheritMdc = + BigQueryJdbcMdc.registerAndBindConnection(inheritConn)) { + assertTrue(logger.isLoggable(Level.FINEST)); + } + + // 2. Child logger with its own handler bypasses per-connection OFF filter + logger.addHandler(testHandler); + try (BigQueryJdbcMdc.MdcCloseable offMdc = BigQueryJdbcMdc.registerInstance(offConn)) { + assertTrue(logger.isLoggable(Level.FINE)); + } + logger.removeHandler(testHandler); + try (BigQueryJdbcMdc.MdcCloseable offMdc = BigQueryJdbcMdc.registerInstance(offConn)) { + assertFalse(logger.isLoggable(Level.FINE)); + } + + // 3. Async MdcThreadPoolExecutor submit() and execute() propagate ConnectionLogContext + ExecutorService pool = BigQueryJdbcMdc.newFixedThreadPool("gate1-test", 1); + try { + Future offCallable; + CountDownLatch offExecDone = new CountDownLatch(1); + AtomicBoolean offExecLoggable = new AtomicBoolean(true); + try (BigQueryJdbcMdc.MdcCloseable offMdc = BigQueryJdbcMdc.registerInstance(offConn)) { + offCallable = pool.submit(() -> logger.isLoggable(Level.FINE)); + pool.execute( + () -> { + offExecLoggable.set(logger.isLoggable(Level.FINE)); + offExecDone.countDown(); + }); + } + assertFalse(offCallable.get()); + assertTrue(offExecDone.await(5, TimeUnit.SECONDS)); + assertFalse(offExecLoggable.get()); + + Future finestCallable; + try (BigQueryJdbcMdc.MdcCloseable finestMdc = + BigQueryJdbcMdc.registerInstance(finestConn)) { + finestCallable = pool.submit(() -> logger.isLoggable(Level.FINEST)); + } + assertTrue(finestCallable.get()); + } finally { + pool.shutdownNow(); + } + + // 4. Explicit global setLevel overrides OFF down to that global floor + BigQueryJdbcRootLogger.setLevel(Level.FINE, tempDir.resolve("global").toString()); + assertTrue(offRsLogger.isLoggable(Level.FINE)); + assertFalse(offRsLogger.isLoggable(Level.FINEST)); + BigQueryJdbcRootLogger.setLevel(Level.OFF, null); + + // 5. Enabling useParentHandlers on rootLogger treats parent delegation as an external sink + rootLogger.setUseParentHandlers(true); + assertTrue(BigQueryJdbcRootLogger.hasExternalHandler()); + assertTrue(offRsLogger.isLoggable(Level.FINEST)); + rootLogger.setUseParentHandlers(false); + assertFalse(BigQueryJdbcRootLogger.hasExternalHandler()); + assertFalse(offRsLogger.isLoggable(Level.FINEST)); + + // 6. Direct verification of scanForExternalHandler on a plain non-RootDriverLogger Logger + Logger plainLogger = new Logger("test.plain.bigquery", null) {}; + plainLogger.setUseParentHandlers(false); + plainLogger.addHandler(new OpenTelemetryJulHandler()); + assertFalse(BigQueryJdbcRootLogger.scanForExternalHandler(plainLogger)); + TestHandler plainExternal = new TestHandler(); + plainLogger.addHandler(plainExternal); + assertTrue(BigQueryJdbcRootLogger.scanForExternalHandler(plainLogger)); + plainLogger.removeHandler(plainExternal); + assertFalse(BigQueryJdbcRootLogger.scanForExternalHandler(plainLogger)); + plainLogger.setUseParentHandlers(true); + assertTrue(BigQueryJdbcRootLogger.scanForExternalHandler(plainLogger)); + + // 7. Re-attaching an external JUL handler on rootLogger restores visibility + rootLogger.addHandler(this.handler); + rootLogger.setLevel(Level.ALL); + assertTrue(BigQueryJdbcRootLogger.hasExternalHandler()); + assertTrue(offRsLogger.isLoggable(Level.FINEST)); + } finally { + rootLogger.setUseParentHandlers(false); + BigQueryJdbcRootLogger.setLevel(Level.OFF, null); + BigQueryJdbcRootLogger.closeConnectionHandler(finestConn); + BigQueryJdbcRootLogger.closeConnectionHandler(offConn); + BigQueryJdbcRootLogger.closeConnectionHandler(inheritConn); + restoreTestHandlers(rootLogger); + } + } + + private void assertNullSafeDelegateDefaultLevel(BigQueryJdbcResultSetLogger rsLogger) { + assertEquals(null, rsLogger.delegate().getLevel()); + } + + private void restoreTestHandlers(Logger rootLogger) { + if (!Arrays.asList(rootLogger.getHandlers()).contains(this.handler)) { + rootLogger.addHandler(this.handler); + } + if (!Arrays.asList(logger.getHandlers()).contains(testHandler)) { + logger.addHandler(testHandler); + } + rootLogger.setLevel(Level.ALL); + } + /** * Reads the JDK-internal {@code Logger.kids} list. This field is private to {@code java.logging}, * so the surefire {@code argLine} opens {@code java.util.logging} to the test classpath.