Merge branch 'main' into flatten-generated-modules

Author: chingor13

.kokoro/presubmit/google-auth-library-java-graalvm-native-presubmit.cfg

@@ -50,3 +50,9 @@ env_vars: {
   key: "BUILD_SUBDIR"
   value: "google-auth-library-java"
 }
+
+env_vars: {
+  key: "INTEGRATION_TEST_ARGS"
+  value: "-Pslf4j2x"
+}
+

google-auth-library-java/appengine/pom.xml

@@ -42,6 +42,14 @@
           </archive> 
         </configuration>
       </plugin>
+      <plugin>
+        <groupId>org.graalvm.buildtools</groupId>
+        <artifactId>native-maven-plugin</artifactId>
+        <configuration>
+          <skipNativeTests>true</skipNativeTests>
+        </configuration>
+      </plugin>
+
     </plugins>
   </build>
 

google-auth-library-java/cab-token-generator/javatests/com/google/auth/credentialaccessboundary/ClientSideCredentialAccessBoundaryFactoryTest.java

@@ -614,22 +614,28 @@ private Clock createMockClock(RefreshType refreshType, GoogleCredentials sourceC
         // Set mocked time so that the token is fresh and no refresh is needed (before the refresh
         // margin).
         mockedTimeInMillis = expirationTimeInMillis - refreshMarginInMillis - 60000;
+        when(mockClock.currentTimeMillis()).thenReturn(mockedTimeInMillis);
         break;
       case ASYNC:
         // Set mocked time so that the token is nearing expiry and an async refresh is triggered
         // (within the refresh margin).
         mockedTimeInMillis = expirationTimeInMillis - refreshMarginInMillis + 60000;
+        when(mockClock.currentTimeMillis())
+            .thenReturn(
+                mockedTimeInMillis, // First call: Stale (triggers the async refresh)
+                currentTimeInMillis // Subsequent calls: Fresh (skips redundant refreshes)
+                );
         break;
       case BLOCKING:
         // Set mocked time so that the token requires immediate refresh (just after the minimum
         // token lifetime).
         mockedTimeInMillis = expirationTimeInMillis - minimumTokenLifetimeMillis + 60000;
+        when(mockClock.currentTimeMillis()).thenReturn(mockedTimeInMillis);
         break;
       default:
         throw new IllegalArgumentException("Unexpected RefreshType: " + refreshType);
     }
 
-    when(mockClock.currentTimeMillis()).thenReturn(mockedTimeInMillis);
     return mockClock;
   }
 

google-auth-library-java/credentials/pom.xml

@@ -22,6 +22,13 @@
     <sourceDirectory>java</sourceDirectory>
     <testSourceDirectory>javatests</testSourceDirectory>
     <plugins>
+      <plugin>
+        <groupId>org.graalvm.buildtools</groupId>
+        <artifactId>native-maven-plugin</artifactId>
+        <configuration>
+          <skipNativeTests>true</skipNativeTests>
+        </configuration>
+      </plugin>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-source-plugin</artifactId>

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

@@ -16,6 +16,7 @@
 
 package com.google.cloud.bigquery.jdbc;
 
+import com.google.common.base.Strings;
 import java.io.IOException;
 import java.lang.management.ManagementFactory;
 import java.nio.file.Files;
@@ -24,7 +25,6 @@
 import java.nio.file.StandardCopyOption;
 import java.text.SimpleDateFormat;
 import java.util.Date;
-import java.util.Optional;
 import java.util.logging.ConsoleHandler;
 import java.util.logging.FileHandler;
 import java.util.logging.Formatter;
@@ -49,6 +49,32 @@ class BigQueryJdbcRootLogger {
   private static Path currentLogPath = null;
   private static int fileCounter = 0;
 
+  static final String PROCESS_ID = ManagementFactory.getRuntimeMXBean().getName().split("@")[0];
+
+  private static final ThreadLocal<SimpleDateFormat> DATE_FORMATTER =
+      ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS"));
+
+  static String getThreadName(long threadId) {
+    Thread current = Thread.currentThread();
+    if (current.getId() == threadId) {
+      return current.getName();
+    }
+    ThreadGroup rootGroup = current.getThreadGroup();
+    while (rootGroup.getParent() != null) {
+      rootGroup = rootGroup.getParent();
+    }
+
+    int count = rootGroup.activeCount();
+    Thread[] threads = new Thread[count * 2];
+    int actualCount = rootGroup.enumerate(threads);
+    for (int i = 0; i < actualCount; i++) {
+      if (threads[i].getId() == threadId) {
+        return threads[i].getName();
+      }
+    }
+    return "";
+  }
+
   static {
     logger.setUseParentHandlers(false);
     storageLogger.setUseParentHandlers(true);
@@ -62,49 +88,43 @@ class BigQueryJdbcRootLogger {
 
   public static Formatter getFormatter() {
     return new Formatter() {
-      private static final String PATTERN = "yyyy-MM-dd HH:mm:ss.SSS";
-      private static final String FORMAT =
-          "%1$s %2$5s %3$d --- [%4$-7.15s] %5$-50s %6$-20s: %7$s%8$s";
       private static final int MAX_THREAD_NAME_LENGTH = 15;
 
-      /**
-       * Returns the thread for the given thread id.
-       *
-       * @param threadId ID for the thread being logged.
-       * @return returns the thread
-       */
-      Optional<Thread> getThread(long threadId) {
-        return Thread.getAllStackTraces().keySet().stream()
-            .filter(thread -> thread.getId() == threadId)
-            .findFirst();
-      }
-
       @Override
       public String format(LogRecord record) {
-        String date = new SimpleDateFormat(PATTERN).format(new Date(record.getMillis()));
-        String threadName =
-            getThread(record.getThreadID())
-                .map(Thread::getName)
-                .map(
-                    name ->
-                        name.length() > MAX_THREAD_NAME_LENGTH
-                            ? name.substring(name.length() - MAX_THREAD_NAME_LENGTH)
-                            : name)
-                .orElse("");
-        long processId =
-            Long.parseLong(ManagementFactory.getRuntimeMXBean().getName().split("@")[0]);
+        String date = DATE_FORMATTER.get().format(new Date(record.getMillis()));
+
+        long threadId = record.getThreadID();
+        String threadName = getThreadName(threadId);
+
+        if (threadName.length() > MAX_THREAD_NAME_LENGTH) {
+          threadName = threadName.substring(threadName.length() - MAX_THREAD_NAME_LENGTH);
+        }
+
         String sourceClassName = record.getLoggerName();
         String sourceMethodName = record.getSourceMethodName();
-        return String.format(
-            FORMAT,
-            date,
-            record.getLevel().getName(),
-            processId,
-            threadName,
-            sourceClassName,
-            sourceMethodName,
-            record.getMessage(),
-            System.lineSeparator());
+
+        // Expected log format: yyyy-MM-dd HH:mm:ss.SSS LEVEL PID --- [THREAD] CLASS METHOD: MESSAGE
+        // Example: 2026-04-22 10:16:00.123  INFO 12345 --- [main   ]
+        // com.google.cloud.bigquery.jdbc.BigQueryConnection connect             : Connection
+        // successful
+        StringBuilder sb = new StringBuilder(256);
+        sb.append(date)
+            .append(" ")
+            .append(Strings.padStart(record.getLevel().getName(), 5, ' '))
+            .append(" ")
+            .append(PROCESS_ID)
+            .append(" --- [")
+            .append(Strings.padEnd(threadName, 7, ' '))
+            .append("] ")
+            .append(Strings.padEnd(sourceClassName != null ? sourceClassName : "", 50, ' '))
+            .append(" ")
+            .append(Strings.padEnd(sourceMethodName != null ? sourceMethodName : "", 20, ' '))
+            .append(": ")
+            .append(record.getMessage())
+            .append(System.lineSeparator());
+
+        return sb.toString();
       }
     };
   }

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

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.cloud.bigquery.jdbc;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.logging.Formatter;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import org.junit.jupiter.api.Test;
+
+public class BigQueryJdbcRootLoggerTest {
+
+  @Test
+  public void testGetFormatterFormat() {
+    Formatter formatter = BigQueryJdbcRootLogger.getFormatter();
+    assertNotNull(formatter);
+
+    LogRecord record = new LogRecord(Level.INFO, "Test message");
+    record.setMillis(1713715200000L);
+    record.setLoggerName("TestLogger");
+    record.setSourceMethodName("testMethod");
+
+    String formatted = formatter.format(record);
+
+    assertTrue(formatted.contains("INFO"));
+    assertTrue(formatted.contains("Test message"));
+    assertTrue(formatted.contains("TestLogger"));
+    assertTrue(formatted.contains("testMethod"));
+    assertTrue(formatted.contains("---"));
+  }
+
+  @Test
+  public void testThreadNameTruncation() {
+    Formatter formatter = BigQueryJdbcRootLogger.getFormatter();
+    LogRecord record = new LogRecord(Level.INFO, "Test message");
+
+    String formatted = formatter.format(record);
+    int startIndex = formatted.indexOf("--- [") + 5;
+    int endIndex = formatted.indexOf("]", startIndex);
+    String threadPart = formatted.substring(startIndex, endIndex).trim();
+
+    assertTrue(threadPart.length() <= 15);
+  }
+
+  @Test
+  public void testGetThreadName() {
+    Thread current = Thread.currentThread();
+    String name = BigQueryJdbcRootLogger.getThreadName(current.getId());
+    assertEquals(current.getName(), name);
+  }
+
+  @Test
+  public void testGetThreadNameNotFound() {
+    String name = BigQueryJdbcRootLogger.getThreadName(-1);
+    assertEquals("", name);
+  }
+}

java-bigquery/google-cloud-bigquery/src/test/java/com/google/cloud/bigquery/FieldValueTest.java

@@ -151,6 +151,18 @@ public void testInt64Timestamp() {
     assertEquals(expected, received);
   }
 
+  @Test
+  public void testLosslessMaxTimestamp() {
+    // Test the lossless behavior (useInt64Timestamps = true)
+    // The backend returns a 64-bit integer string for microseconds when this option is enabled
+    String losslessTimestampString = "253402300799999999";
+    FieldValue losslessValue =
+        FieldValue.of(FieldValue.Attribute.PRIMITIVE, losslessTimestampString, true);
+
+    // Exactly matches the microsecond equivalent of 9999-12-31 23:59:59.999999
+    assertEquals(253402300799999999L, losslessValue.getTimestampValue());
+  }
+
   @Test
   public void testEquals() {
     FieldValue booleanValue = FieldValue.of(FieldValue.Attribute.PRIMITIVE, "false");

java-bigquery/google-cloud-bigquery/src/test/java/com/google/cloud/bigquery/it/ITBigQueryTest.java

@@ -1215,6 +1215,56 @@ static GoogleCredentials loadCredentials(String credentialFile) {
     }
   }
 
+  @Test
+  void testLosslessMaxTimestampIntegration() throws InterruptedException {
+    String query = "SELECT TIMESTAMP '9999-12-31 23:59:59.999999 UTC' as max_ts";
+    QueryJobConfiguration config = QueryJobConfiguration.newBuilder(query).build();
+
+    // 1. Test lossless 64-bit integer parsing (useInt64Timestamps = true)
+    DataFormatOptions losslessOptions =
+        DataFormatOptions.newBuilder().useInt64Timestamp(true).build();
+    BigQuery losslessBigQuery =
+        bigquery.getOptions().toBuilder()
+            .setDataFormatOptions(losslessOptions)
+            .build()
+            .getService();
+
+    TableResult losslessResult = losslessBigQuery.query(config);
+    assertEquals(1L, losslessResult.getTotalRows());
+    for (FieldValueList row : losslessResult.iterateAll()) {
+      long exactMicros = row.get("max_ts").getTimestampValue();
+      assertEquals(253402300799999999L, exactMicros);
+    }
+
+    // 2. Test lossy FLOAT64 rounding behavior (useInt64Timestamps = false)
+    DataFormatOptions floatOptions =
+        DataFormatOptions.newBuilder().useInt64Timestamp(false).build();
+    BigQuery floatBigQuery =
+        bigquery.getOptions().toBuilder().setDataFormatOptions(floatOptions).build().getService();
+
+    TableResult floatResult = floatBigQuery.query(config);
+    assertEquals(1L, floatResult.getTotalRows());
+    for (FieldValueList row : floatResult.iterateAll()) {
+      long roundedMicros = row.get("max_ts").getTimestampValue();
+      assertEquals(253402300800000000L, roundedMicros);
+    }
+
+    // 3. Test ISO8601 timestamp formatting
+    DataFormatOptions isoOptions =
+        DataFormatOptions.newBuilder()
+            .timestampFormatOptions(DataFormatOptions.TimestampFormatOptions.ISO8601_STRING)
+            .build();
+    BigQuery isoBigQuery =
+        bigquery.getOptions().toBuilder().setDataFormatOptions(isoOptions).build().getService();
+
+    TableResult isoResult = isoBigQuery.query(config);
+    assertEquals(1L, isoResult.getTotalRows());
+    for (FieldValueList row : isoResult.iterateAll()) {
+      String isoValue = row.get("max_ts").getStringValue();
+      assertEquals("9999-12-31T23:59:59.999999Z", isoValue);
+    }
+  }
+
   @Test
   void testListDatasets() {
     Page<Dataset> datasets = bigquery.listDatasets("bigquery-public-data");