fix(bigquery-jdbc): use one logger per class to stop child-logger registration leak (#14716)

b/576218509

- Replace the per-instance `LOG = new
BigQueryJdbcCustomLogger(this.toString())`
  field with one `static final` logger per class in `BigQueryStatement`,
`BigQueryConnection`, `BigQueryDatabaseMetaData`,
`BigQueryCallableStatement`,
  `BigQueryPooledConnection` (+ `BigQueryPooledConnectionWrapper`),
`PooledConnectionListener`, and `DataSource`. Each logger is named after
its
own class so the `CLASS` column fallback in the formatter stays correct.
- Remove the duplicate `setParent(...)` call in the 1-arg
`BigQueryJdbcCustomLogger` constructor; the 2-arg constructor it
delegates to
already sets the parent. The second call forced a full scan of the
parent's
  child list under the global `treeLock` on every construction.
- Add regression tests to `BigQueryJdbcCustomLoggerTest`:
- `testLoggerIsParentedToDriverRootLogger` locks in that every logger is
still parented to the driver root logger (handlers/levels keep flowing).
  - `testCreatingStatementsDoesNotRegisterChildLoggers` and
`testCreatingDatabaseMetaDataDoesNotRegisterChildLoggers` construct
1,000
objects and assert the root logger's child count does not grow. Both
fail
    on `main` and pass with this change.
- Add `--add-opens=java.logging/java.util.logging=ALL-UNNAMED` to the
surefire
`argLine` (test-only) so the regression tests can read the JDK-internal
  child-logger list on JDK 17+.

No behavior change to per-connection log files or formatting: routing
and the
`[CONNECTION_ID]` column come from the MDC / record parameters, not from
the
logger name.

Author: Neenu1995

java-bigquery-jdbc/pom.xml

@@ -506,7 +506,12 @@
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-surefire-plugin</artifactId>
             <configuration>
-              <argLine>--add-opens=java.base/java.nio=org.apache.arrow.memory.core,ALL-UNNAMED</argLine>
+              <!--
+              java.nio is opened for Arrow's off-heap memory access. java.util.logging is opened
+              so BigQueryJdbcCustomLoggerTest can read the JDK-internal child-logger list and
+              assert that driver objects do not leak logger registrations.
+              -->
+              <argLine>--add-opens=java.base/java.nio=org.apache.arrow.memory.core,ALL-UNNAMED --add-opens=java.logging/java.util.logging=ALL-UNNAMED</argLine>
             </configuration>
           </plugin>
           <plugin>

java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryCallableStatement.java

@@ -43,7 +43,8 @@
 import java.util.Map;
 
 class BigQueryCallableStatement extends BigQueryPreparedStatement implements CallableStatement {
-  private final BigQueryJdbcCustomLogger LOG = new BigQueryJdbcCustomLogger(this.toString());
+  private static final BigQueryJdbcCustomLogger LOG =
+      new BigQueryJdbcCustomLogger(BigQueryCallableStatement.class.getName());
   private boolean lastReadWasNull = false;
 
   private Object getParameterAndTrackNull(int parameterIndex) throws SQLException {

java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryConnection.java

@@ -92,7 +92,8 @@
  */
 public class BigQueryConnection extends BigQueryNoOpsConnection {
 
-  private final BigQueryJdbcCustomLogger LOG = new BigQueryJdbcCustomLogger(this.toString());
+  private static final BigQueryJdbcCustomLogger LOG =
+      new BigQueryJdbcCustomLogger(BigQueryConnection.class.getName());
   String connectionClassName = this.toString();
   private final String connectionId;
   private static final String DEFAULT_JDBC_TOKEN_VALUE = "Google-BigQuery-JDBC-Driver";

java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryDatabaseMetaData.java

@@ -91,7 +91,8 @@
  * @see BigQueryStatement
  */
 class BigQueryDatabaseMetaData implements DatabaseMetaData {
-  final BigQueryJdbcCustomLogger LOG = new BigQueryJdbcCustomLogger(this.toString());
+  static final BigQueryJdbcCustomLogger LOG =
+      new BigQueryJdbcCustomLogger(BigQueryDatabaseMetaData.class.getName());
   private static final String DATABASE_PRODUCT_NAME = "Google BigQuery";
   private static final String DATABASE_PRODUCT_VERSION = "2.0";
   private static final String DRIVER_NAME = "GoogleJDBCDriverForGoogleBigQuery";

java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcCustomLogger.java

@@ -30,7 +30,6 @@ protected BigQueryJdbcCustomLogger(String name, String resourceBundleName) {
 
   public BigQueryJdbcCustomLogger(String name) {
     this(name, null);
-    this.setParent(BigQueryJdbcRootLogger.getRootLogger());
   }
 
   private void logWithCaller(Level level, Supplier<String> msgSupplier) {

java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryPooledConnection.java

@@ -31,7 +31,8 @@
 import javax.sql.StatementEventListener;
 
 class BigQueryPooledConnection implements PooledConnection {
-  private final BigQueryJdbcCustomLogger LOG = new BigQueryJdbcCustomLogger(this.toString());
+  private static final BigQueryJdbcCustomLogger LOG =
+      new BigQueryJdbcCustomLogger(BigQueryPooledConnection.class.getName());
 
   private String id; // Mainly for internal use
   private Connection bqConnection;
@@ -165,7 +166,8 @@ public void removeStatementEventListener(StatementEventListener arg0) {
   // This class notifies the listeners or calls the listner notification methods
   // provided by the pooled connection.
   static class BigQueryPooledConnectionWrapper implements Connection {
-    private final BigQueryJdbcCustomLogger LOG = new BigQueryJdbcCustomLogger(this.toString());
+    private static final BigQueryJdbcCustomLogger LOG =
+        new BigQueryJdbcCustomLogger(BigQueryPooledConnectionWrapper.class.getName());
     private Connection bqConnectionDelegate;
     private BigQueryPooledConnection pooledConnection;
     private boolean closed = false;

java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/BigQueryStatement.java

@@ -102,7 +102,8 @@
  */
 public class BigQueryStatement extends BigQueryNoOpsStatement {
 
-  private final BigQueryJdbcCustomLogger LOG = new BigQueryJdbcCustomLogger(this.toString());
+  private static final BigQueryJdbcCustomLogger LOG =
+      new BigQueryJdbcCustomLogger(BigQueryStatement.class.getName());
   public static final int DEFAULT_BUFFER_SIZE = BigQuerySettings.DEFAULT_NUM_BUFFERED_ROWS * 2;
   // Bounds in-memory ArrowRecordBatch buffering per ResultSet (~15-20 MB of in-flight batches),
   // keeping the gRPC ReadRows stream saturated while preventing unbounded heap accumulation.

java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/DataSource.java

@@ -43,7 +43,8 @@
  * registered with a naming service based on the Java™ Naming and Directory (JNDI) API.
  */
 public class DataSource implements javax.sql.DataSource {
-  private final BigQueryJdbcCustomLogger LOG = new BigQueryJdbcCustomLogger(this.toString());
+  private static final BigQueryJdbcCustomLogger LOG =
+      new BigQueryJdbcCustomLogger(DataSource.class.getName());
   private String URL;
   static final ImmutableSet<Integer> VALID_JOB_CREATION_MODES = ImmutableSet.of(1, 2);
 

java-bigquery-jdbc/src/main/java/com/google/cloud/bigquery/jdbc/PooledConnectionListener.java

@@ -23,7 +23,8 @@
 import javax.sql.PooledConnection;
 
 public class PooledConnectionListener implements ConnectionEventListener {
-  private final BigQueryJdbcCustomLogger LOG = new BigQueryJdbcCustomLogger(this.toString());
+  private static final BigQueryJdbcCustomLogger LOG =
+      new BigQueryJdbcCustomLogger(PooledConnectionListener.class.getName());
   private String id; // Mainly for internal use
   private LinkedBlockingDeque<PooledConnection> connectionPool;
   private Long connectionPoolSize = 0L;

java-bigquery-jdbc/src/test/java/com/google/cloud/bigquery/jdbc/BigQueryJdbcCustomLoggerTest.java

@@ -20,6 +20,8 @@
 import static org.junit.jupiter.api.Assertions.assertNotSame;
 import static org.junit.jupiter.api.Assertions.assertSame;
 import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
 
 import com.google.cloud.bigquery.Field;
 import com.google.cloud.bigquery.FieldList;
@@ -37,6 +39,7 @@
 import java.util.logging.Handler;
 import java.util.logging.Level;
 import java.util.logging.LogRecord;
+import java.util.logging.Logger;
 import org.apache.arrow.vector.util.JsonStringArrayList;
 import org.apache.arrow.vector.util.JsonStringHashMap;
 import org.junit.jupiter.api.AfterEach;
@@ -49,6 +52,8 @@ public class BigQueryJdbcCustomLoggerTest extends BigQueryJdbcLoggingBaseTest {
   private BigQueryJdbcCustomLogger logger;
   private TestHandler testHandler;
 
+  private static final int OBJECT_COUNT = 1_000;
+
   private static class TestHandler extends Handler {
     private final List<LogRecord> records = new ArrayList<>();
 
@@ -579,4 +584,69 @@ public void testNestedArrayInJsonStructConnectionIdPropagation() throws Exceptio
         "Log from Nested JSON Array",
         () -> nestedArray.LOG.fine("Log from Nested JSON Array"));
   }
+
+  @Test
+  public void testLoggerIsParentedToDriverRootLogger() {
+    assertSame(
+        BigQueryJdbcRootLogger.getRootLogger(),
+        new BigQueryJdbcCustomLogger("ParentCheck").getParent());
+  }
+
+  @Test
+  public void testCreatingStatementsDoesNotRegisterChildLoggers() throws Exception {
+    BigQueryConnection connection = mock(BigQueryConnection.class);
+    doReturn("leak-test-connection").when(connection).getConnectionId();
+    doReturn(BigQueryConnection.SessionState.empty()).when(connection).getSessionStateSnapshot();
+
+    Logger rootLogger = BigQueryJdbcRootLogger.getRootLogger();
+    // Warm up so that any one-time, class-level logger is registered before we measure.
+    new BigQueryStatement(connection);
+    int childrenBefore = childLoggerCount(rootLogger);
+
+    for (int i = 0; i < OBJECT_COUNT; i++) {
+      new BigQueryStatement(connection);
+    }
+
+    assertEquals(
+        childrenBefore,
+        childLoggerCount(rootLogger),
+        "Creating "
+            + OBJECT_COUNT
+            + " statements must not register additional child loggers on the driver root logger");
+  }
+
+  @Test
+  public void testCreatingDatabaseMetaDataDoesNotRegisterChildLoggers()
+      throws ReflectiveOperationException {
+    BigQueryConnection connection = mock(BigQueryConnection.class);
+    doReturn("leak-test-connection").when(connection).getConnectionId();
+
+    Logger rootLogger = BigQueryJdbcRootLogger.getRootLogger();
+    new BigQueryDatabaseMetaData(connection);
+    int childrenBefore = childLoggerCount(rootLogger);
+
+    for (int i = 0; i < OBJECT_COUNT; i++) {
+      new BigQueryDatabaseMetaData(connection);
+    }
+
+    assertEquals(
+        childrenBefore,
+        childLoggerCount(rootLogger),
+        "Creating "
+            + OBJECT_COUNT
+            + " DatabaseMetaData objects must not register additional child loggers on the driver"
+            + " root logger");
+  }
+
+  /**
+   * 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.
+   */
+  private static int childLoggerCount(Logger logger) throws ReflectiveOperationException {
+    // Qualified because this file already imports com.google.cloud.bigquery.Field.
+    java.lang.reflect.Field kids = Logger.class.getDeclaredField("kids");
+    kids.setAccessible(true);
+    List<?> children = (List<?>) kids.get(logger);
+    return children == null ? 0 : children.size();
+  }
 }