Use uv for managing python version

.envrc

@@ -1,2 +1,3 @@
-export VIRTUAL_ENV=".venv"
-layout python3
+export VIRTUAL_ENV="${PWD}/.venv"
+devenv sync
+PATH_add "${PWD}/.venv/bin"

.gitignore

@@ -27,3 +27,4 @@ spring-server.txt
 spy.log
 .kotlin
 **/tomcat.8080/webapps/
+**/__pycache__

.python-version

@@ -0,0 +1 @@
+3.13.3

devenv/config.ini

@@ -0,0 +1,16 @@
+[devenv]
+minimum_version = 1.22.1
+
+[uv]
+darwin_arm64 = https://github.com/astral-sh/uv/releases/download/0.8.2/uv-aarch64-apple-darwin.tar.gz
+darwin_arm64_sha256 = 954d24634d5f37fa26c7af75eb79893d11623fc81b4de4b82d60d1ade4bfca22
+darwin_x86_64 = https://github.com/astral-sh/uv/releases/download/0.8.2/uv-x86_64-apple-darwin.tar.gz
+darwin_x86_64_sha256 = ae755df53c8c2c1f3dfbee6e3d2e00be0dfbc9c9b4bdffdb040b96f43678b7ce
+linux_arm64 = https://github.com/astral-sh/uv/releases/download/0.8.2/uv-aarch64-unknown-linux-gnu.tar.gz
+linux_arm64_sha256 = 27da35ef54e9131c2e305de67dd59a07c19257882c6b1f3cf4d8d5fbb8eaf4ca
+linux_x86_64 = https://github.com/astral-sh/uv/releases/download/0.8.2/uv-x86_64-unknown-linux-gnu.tar.gz
+linux_x86_64_sha256 = 6dcb28a541868a455aefb2e8d4a1283dd6bf888605a2db710f0530cec888b0ad
+# used for autoupdate
+# NOTE: if using uv-build as a build backend, you'll have to make sure the versions match
+version = 0.8.2
+

devenv/sync.py

@@ -0,0 +1,23 @@
+from devenv import constants
+from devenv.lib import config, proc, uv
+import os
+
+def main(context: dict[str, str]) -> int:
+    reporoot = context["reporoot"]
+    cfg = config.get_repo(reporoot)
+
+    uv.install(
+        cfg["uv"]["version"],
+        cfg["uv"][constants.SYSTEM_MACHINE],
+        cfg["uv"][f"{constants.SYSTEM_MACHINE}_sha256"],
+        reporoot,
+    )
+
+    # reporoot/.venv is the default venv location
+    print(f"syncing .venv ...")
+    if not os.path.exists(".venv"):
+        proc.run(("uv", "venv", "--seed"))
+    proc.run(("uv", "sync", "--frozen", "--quiet"))
+
+    return 0
+

pyproject.toml

@@ -0,0 +1,3 @@
+[project]
+name = "javasdk"
+version = "0.0.0"

sentry/src/main/java/io/sentry/SentryClient.java

@@ -1657,6 +1657,7 @@ public void close(final boolean isRestarting) {
     try {
       flush(isRestarting ? 0 : options.getShutdownTimeoutMillis());
       loggerBatchProcessor.close(isRestarting);
+      metricsBatchProcessor.close(isRestarting);
       transport.close(isRestarting);
     } catch (IOException e) {
       options
@@ -1684,6 +1685,7 @@ public void close(final boolean isRestarting) {
   @Override
   public void flush(final long timeoutMillis) {
     loggerBatchProcessor.flush(timeoutMillis);
+    metricsBatchProcessor.flush(timeoutMillis);
     transport.flush(timeoutMillis);
   }
 

sentry/src/test/java/io/sentry/SentryClientTest.kt

@@ -14,7 +14,9 @@ import io.sentry.hints.Cached
 import io.sentry.hints.DiskFlushNotification
 import io.sentry.hints.TransactionEnd
 import io.sentry.logger.ILoggerBatchProcessor
+import io.sentry.logger.ILoggerBatchProcessorFactory
 import io.sentry.metrics.IMetricsBatchProcessor
+import io.sentry.metrics.IMetricsBatchProcessorFactory
 import io.sentry.protocol.Contexts
 import io.sentry.protocol.Feedback
 import io.sentry.protocol.Mechanism
@@ -78,6 +80,10 @@ class SentryClientTest {
   class Fixture {
     var transport = mock<ITransport>()
     var factory = mock<ITransportFactory>()
+    var loggerBatchProcessor = mock<ILoggerBatchProcessor>()
+    var loggerBatchProcessorFactory = mock<ILoggerBatchProcessorFactory>()
+    var metricsBatchProcessor = mock<IMetricsBatchProcessor>()
+    var metricsBatchProcessorFactory = mock<IMetricsBatchProcessorFactory>()
     val maxAttachmentSize: Long = (5 * 1024 * 1024).toLong()
     val scopes = mock<IScopes>()
     val sentryTracer: SentryTracer
@@ -94,12 +100,16 @@ class SentryClientTest {
         setLogger(mock())
         maxAttachmentSize = [email protected]
         setTransportFactory(factory)
+        logs.setLoggerBatchProcessorFactory(loggerBatchProcessorFactory)
+        metrics.setMetricsBatchProcessorFactory(metricsBatchProcessorFactory)
         release = "0.0.1"
         isTraceSampling = true
       }
 
     init {
       whenever(factory.create(any(), any())).thenReturn(transport)
+      whenever(loggerBatchProcessorFactory.create(any(), any())).thenReturn(loggerBatchProcessor)
+      whenever(metricsBatchProcessorFactory.create(any(), any())).thenReturn(metricsBatchProcessor)
       whenever(scopes.options).thenReturn(sentryOptions)
       sentryTracer =
         SentryTracer(
@@ -168,21 +178,29 @@ class SentryClientTest {
 
   @Test
   fun `when client is closed with isRestarting false, transport waits`() {
-    val sut = fixture.getSut()
+    val sut = fixture.getSut { options -> options.logs.isEnabled = true }
     assertTrue(sut.isEnabled)
     sut.close(false)
     assertNotEquals(0, fixture.sentryOptions.shutdownTimeoutMillis)
     verify(fixture.transport).flush(eq(fixture.sentryOptions.shutdownTimeoutMillis))
+    verify(fixture.loggerBatchProcessor).flush(eq(fixture.sentryOptions.shutdownTimeoutMillis))
+    verify(fixture.metricsBatchProcessor).flush(eq(fixture.sentryOptions.shutdownTimeoutMillis))
     verify(fixture.transport).close(eq(false))
+    verify(fixture.loggerBatchProcessor).close(eq(false))
+    verify(fixture.metricsBatchProcessor).close(eq(false))
   }
 
   @Test
   fun `when client is closed with isRestarting true, transport does not wait`() {
-    val sut = fixture.getSut()
+    val sut = fixture.getSut { options -> options.logs.isEnabled = true }
     assertTrue(sut.isEnabled)
     sut.close(true)
     verify(fixture.transport).flush(eq(0))
+    verify(fixture.loggerBatchProcessor).flush(eq(0))
+    verify(fixture.metricsBatchProcessor).flush(eq(0))
     verify(fixture.transport).close(eq(true))
+    verify(fixture.loggerBatchProcessor).close(eq(true))
+    verify(fixture.metricsBatchProcessor).close(eq(true))
   }
 
   @Test