From 46f15971a5debffb6fb51ca76084eeb92a922257 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Tue, 14 Jan 2025 15:40:01 +0100
Subject: [PATCH 1/7] Make `SentryClient` constructor public (#4045)

* Make SentryClient constructor public

* changelog

* Mark internal
---
 CHANGELOG.md                                     | 6 ++++++
 sentry/api/sentry.api                            | 1 +
 sentry/src/main/java/io/sentry/SentryClient.java | 3 ++-
 3 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 66f2693ab3..6807041b52 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased
+
+### Internal
+
+- Make `SentryClient` constructor public ([#4045](https://github.com/getsentry/sentry-java/pull/4045))
+
 ## 8.0.0-rc.4
 
 ### Features
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 5f4d618ad9..a0d559f12f 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -2484,6 +2484,7 @@ public final class io/sentry/SentryBaseEvent$Serializer {
 }
 
 public final class io/sentry/SentryClient : io/sentry/ISentryClient {
+	public fun <init> (Lio/sentry/SentryOptions;)V
 	public fun captureCheckIn (Lio/sentry/CheckIn;Lio/sentry/IScope;Lio/sentry/Hint;)Lio/sentry/protocol/SentryId;
 	public fun captureEnvelope (Lio/sentry/SentryEnvelope;Lio/sentry/Hint;)Lio/sentry/protocol/SentryId;
 	public fun captureEvent (Lio/sentry/SentryEvent;Lio/sentry/IScope;Lio/sentry/Hint;)Lio/sentry/protocol/SentryId;
diff --git a/sentry/src/main/java/io/sentry/SentryClient.java b/sentry/src/main/java/io/sentry/SentryClient.java
index b518c046c5..1cfbf60313 100644
--- a/sentry/src/main/java/io/sentry/SentryClient.java
+++ b/sentry/src/main/java/io/sentry/SentryClient.java
@@ -45,7 +45,8 @@ public boolean isEnabled() {
     return enabled;
   }
 
-  SentryClient(final @NotNull SentryOptions options) {
+  @ApiStatus.Internal
+  public SentryClient(final @NotNull SentryOptions options) {
     this.options = Objects.requireNonNull(options, "SentryOptions is required.");
     this.enabled = true;
 

From 0cf50f9685ee60958860946984e8869a42e9f40c Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Fri, 17 Jan 2025 14:18:37 +0100
Subject: [PATCH 2/7] Do not set the exception group marker when there is a
 suppressed exception (#4056)

* Do set the exception group marker when there is a suppressed exception

* changelog

* comment out test assertions for is group flag
---
 CHANGELOG.md                                   |  7 +++++++
 .../java/io/sentry/SentryExceptionFactory.java |  4 +++-
 .../io/sentry/SentryExceptionFactoryTest.kt    | 18 +++++++++---------
 3 files changed, 19 insertions(+), 10 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6807041b52..bc8410f7a4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,13 @@
 
 ## Unreleased
 
+### Fixes
+
+- Do not set the exception group marker when there is a suppressed exception ([#4056](https://github.com/getsentry/sentry-java/pull/4056))
+  - Due to how grouping works in Sentry currently sometimes the suppressed exception is treated as the main exception. This change ensures we keep using the main exception and not change how grouping works.
+  - As a consequence the list of exceptions in the group on top of an issue is no longer shown in Sentry UI.
+  - We are planning to improve this in the future but opted for this fix first.
+
 ### Internal
 
 - Make `SentryClient` constructor public ([#4045](https://github.com/getsentry/sentry-java/pull/4045))
diff --git a/sentry/src/main/java/io/sentry/SentryExceptionFactory.java b/sentry/src/main/java/io/sentry/SentryExceptionFactory.java
index 2808df11c0..a6138aa398 100644
--- a/sentry/src/main/java/io/sentry/SentryExceptionFactory.java
+++ b/sentry/src/main/java/io/sentry/SentryExceptionFactory.java
@@ -189,7 +189,9 @@ Deque<SentryException> extractExceptionQueueInternal(
 
       Throwable[] suppressed = currentThrowable.getSuppressed();
       if (suppressed != null && suppressed.length > 0) {
-        exceptionMechanism.setExceptionGroup(true);
+        // Disabled for now as it causes grouping in Sentry to sometimes use
+        // the suppressed exception as main exception.
+        // exceptionMechanism.setExceptionGroup(true);
         for (Throwable suppressedThrowable : suppressed) {
           extractExceptionQueueInternal(
               suppressedThrowable, exceptionId, circularityDetector, exceptions);
diff --git a/sentry/src/test/java/io/sentry/SentryExceptionFactoryTest.kt b/sentry/src/test/java/io/sentry/SentryExceptionFactoryTest.kt
index 8eb7f0e42d..69a7721359 100644
--- a/sentry/src/test/java/io/sentry/SentryExceptionFactoryTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryExceptionFactoryTest.kt
@@ -231,7 +231,7 @@ class SentryExceptionFactoryTest {
 
         assertEquals("message", mainInQueue.value)
         assertEquals(0, mainInQueue.mechanism?.exceptionId)
-        assertEquals(true, mainInQueue.mechanism?.isExceptionGroup)
+//        assertEquals(true, mainInQueue.mechanism?.isExceptionGroup)
     }
 
     @Test
@@ -255,12 +255,12 @@ class SentryExceptionFactoryTest {
         assertEquals("inner", mainInQueue.value)
         assertEquals(1, mainInQueue.mechanism?.exceptionId)
         assertEquals(0, mainInQueue.mechanism?.parentId)
-        assertEquals(true, mainInQueue.mechanism?.isExceptionGroup)
+//        assertEquals(true, mainInQueue.mechanism?.isExceptionGroup)
 
         assertEquals("outer", outerInQueue.value)
         assertEquals(0, outerInQueue.mechanism?.exceptionId)
         assertNull(outerInQueue.mechanism?.parentId)
-        assertNull(outerInQueue.mechanism?.isExceptionGroup)
+//        assertNull(outerInQueue.mechanism?.isExceptionGroup)
     }
 
     @Test
@@ -288,12 +288,12 @@ class SentryExceptionFactoryTest {
         assertEquals("inner", mainInQueue.value)
         assertEquals(1, mainInQueue.mechanism?.exceptionId)
         assertEquals(0, mainInQueue.mechanism?.parentId)
-        assertEquals(true, mainInQueue.mechanism?.isExceptionGroup)
+//        assertEquals(true, mainInQueue.mechanism?.isExceptionGroup)
 
         assertEquals("outer", outerInQueue.value)
         assertEquals(0, outerInQueue.mechanism?.exceptionId)
         assertNull(outerInQueue.mechanism?.parentId)
-        assertNull(outerInQueue.mechanism?.isExceptionGroup)
+//        assertNull(outerInQueue.mechanism?.isExceptionGroup)
     }
 
     @Test
@@ -324,7 +324,7 @@ class SentryExceptionFactoryTest {
         assertEquals("innermost", innerMostExceptionInQueue.value)
         assertEquals(3, innerMostExceptionInQueue.mechanism?.exceptionId)
         assertEquals(1, innerMostExceptionInQueue.mechanism?.parentId)
-        assertEquals(true, innerMostExceptionInQueue.mechanism?.isExceptionGroup)
+//        assertEquals(true, innerMostExceptionInQueue.mechanism?.isExceptionGroup)
 
         assertEquals("suppressed", innerSuppressedInQueue.value)
         assertEquals(2, innerSuppressedInQueue.mechanism?.exceptionId)
@@ -334,7 +334,7 @@ class SentryExceptionFactoryTest {
         assertEquals("inner", innerExceptionInQueue.value)
         assertEquals(1, innerExceptionInQueue.mechanism?.exceptionId)
         assertEquals(0, innerExceptionInQueue.mechanism?.parentId)
-        assertEquals(true, innerExceptionInQueue.mechanism?.isExceptionGroup)
+//        assertEquals(true, innerExceptionInQueue.mechanism?.isExceptionGroup)
 
         assertEquals("outer", outerInQueue.value)
         assertEquals(0, outerInQueue.mechanism?.exceptionId)
@@ -378,7 +378,7 @@ class SentryExceptionFactoryTest {
         assertEquals("innermost", innerMostExceptionInQueue.value)
         assertEquals(3, innerMostExceptionInQueue.mechanism?.exceptionId)
         assertEquals(1, innerMostExceptionInQueue.mechanism?.parentId)
-        assertEquals(true, innerMostExceptionInQueue.mechanism?.isExceptionGroup)
+//        assertEquals(true, innerMostExceptionInQueue.mechanism?.isExceptionGroup)
 
         assertEquals("suppressed", innerSuppressedInQueue.value)
         assertEquals(2, innerSuppressedInQueue.mechanism?.exceptionId)
@@ -388,7 +388,7 @@ class SentryExceptionFactoryTest {
         assertEquals("inner", innerExceptionInQueue.value)
         assertEquals(1, innerExceptionInQueue.mechanism?.exceptionId)
         assertEquals(0, innerExceptionInQueue.mechanism?.parentId)
-        assertEquals(true, innerExceptionInQueue.mechanism?.isExceptionGroup)
+//        assertEquals(true, innerExceptionInQueue.mechanism?.isExceptionGroup)
 
         assertEquals("outer", outerInQueue.value)
         assertEquals(0, outerInQueue.mechanism?.exceptionId)

From 23235b938a317fd3c5d96ca1af6e5d8d63f69cc5 Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Mon, 20 Jan 2025 15:25:06 +0100
Subject: [PATCH 3/7] Only send {{auto}} ip-adress if sendDefaultPii is enabled
 (8.x.x) (#4072)

* Only provide {{auto}} ip-address if sendDefaultPii is enabled

* Update Changelog

* Fix PR number

* Fix test
---
 CHANGELOG.md                                  |  5 +++++
 .../android/core/AnrV2EventProcessor.java     |  2 +-
 .../core/DefaultAndroidEventProcessor.java    |  2 +-
 .../android/core/AnrV2EventProcessorTest.kt   | 18 ++++++++++++---
 .../core/DefaultAndroidEventProcessorTest.kt  | 22 ++++++++++++++++---
 .../java/io/sentry/MainEventProcessor.java    |  2 +-
 .../java/io/sentry/MainEventProcessorTest.kt  | 10 +++++++++
 7 files changed, 52 insertions(+), 9 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index bc8410f7a4..93c0e14b38 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,11 @@
 
 ## Unreleased
 
+### Behavioural Changes
+
+- The user ip-address is now only set to `"{{auto}}"` if sendDefaultPii is enabled ([#4072](https://github.com/getsentry/sentry-java/pull/4072))
+    - This change gives you control over IP address collection directly on the client
+
 ### Fixes
 
 - Do not set the exception group marker when there is a suppressed exception ([#4056](https://github.com/getsentry/sentry-java/pull/4056))
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AnrV2EventProcessor.java b/sentry-android-core/src/main/java/io/sentry/android/core/AnrV2EventProcessor.java
index 7295671e44..76beb87840 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/AnrV2EventProcessor.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/AnrV2EventProcessor.java
@@ -580,7 +580,7 @@ private void mergeUser(final @NotNull SentryBaseEvent event) {
     if (user.getId() == null) {
       user.setId(getDeviceId());
     }
-    if (user.getIpAddress() == null) {
+    if (user.getIpAddress() == null && options.isSendDefaultPii()) {
       user.setIpAddress(IpAddressUtils.DEFAULT_IP_ADDRESS);
     }
   }
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/DefaultAndroidEventProcessor.java b/sentry-android-core/src/main/java/io/sentry/android/core/DefaultAndroidEventProcessor.java
index ff85162a38..9125c66da2 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/DefaultAndroidEventProcessor.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/DefaultAndroidEventProcessor.java
@@ -156,7 +156,7 @@ private void mergeUser(final @NotNull SentryBaseEvent event) {
     if (user.getId() == null) {
       user.setId(Installation.id(context));
     }
-    if (user.getIpAddress() == null) {
+    if (user.getIpAddress() == null && options.isSendDefaultPii()) {
       user.setIpAddress(IpAddressUtils.DEFAULT_IP_ADDRESS);
     }
   }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/AnrV2EventProcessorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/AnrV2EventProcessorTest.kt
index d930333f4c..02044c81bf 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/AnrV2EventProcessorTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/AnrV2EventProcessorTest.kt
@@ -85,7 +85,6 @@ class AnrV2EventProcessorTest {
         lateinit var context: Context
         val options = SentryAndroidOptions().apply {
             setLogger(NoOpLogger.getInstance())
-            isSendDefaultPii = true
         }
 
         fun getSut(
@@ -93,10 +92,13 @@ class AnrV2EventProcessorTest {
             currentSdk: Int = Build.VERSION_CODES.LOLLIPOP,
             populateScopeCache: Boolean = false,
             populateOptionsCache: Boolean = false,
-            replayErrorSampleRate: Double? = null
+            replayErrorSampleRate: Double? = null,
+            isSendDefaultPii: Boolean = true
         ): AnrV2EventProcessor {
             options.cacheDirPath = dir.newFolder().absolutePath
             options.environment = "release"
+            options.isSendDefaultPii = isSendDefaultPii
+
             whenever(buildInfo.sdkInfoVersion).thenReturn(currentSdk)
             whenever(buildInfo.isEmulator).thenReturn(true)
 
@@ -278,6 +280,7 @@ class AnrV2EventProcessorTest {
         // user
         assertEquals("bot", processed.user!!.username)
         assertEquals("bot@me.com", processed.user!!.id)
+        assertEquals("{{auto}}", processed.user!!.ipAddress)
         // trace
         assertEquals("ui.load", processed.contexts.trace!!.operation)
         // tags
@@ -304,6 +307,13 @@ class AnrV2EventProcessorTest {
         assertEquals("Google Chrome", processed.contexts.browser!!.name)
     }
 
+    @Test
+    fun `when backfillable event is enrichable, does not backfill user ip`() {
+        val hint = HintUtils.createWithTypeCheckHint(BackfillableHint())
+        val processed = processEvent(hint, isSendDefaultPii = false, populateScopeCache = true)
+        assertNull(processed.user!!.ipAddress)
+    }
+
     @Test
     fun `when backfillable event is enrichable, backfills serialized options data`() {
         val hint = HintUtils.createWithTypeCheckHint(BackfillableHint())
@@ -617,6 +627,7 @@ class AnrV2EventProcessorTest {
         hint: Hint,
         populateScopeCache: Boolean = false,
         populateOptionsCache: Boolean = false,
+        isSendDefaultPii: Boolean = true,
         configureEvent: SentryEvent.() -> Unit = {}
     ): SentryEvent {
         val original = SentryEvent().apply(configureEvent)
@@ -624,7 +635,8 @@ class AnrV2EventProcessorTest {
         val processor = fixture.getSut(
             tmpDir,
             populateScopeCache = populateScopeCache,
-            populateOptionsCache = populateOptionsCache
+            populateOptionsCache = populateOptionsCache,
+            isSendDefaultPii = isSendDefaultPii
         )
         return processor.process(original, hint)!!
     }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/DefaultAndroidEventProcessorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/DefaultAndroidEventProcessorTest.kt
index 9aac83ebad..d3523dd1b5 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/DefaultAndroidEventProcessorTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/DefaultAndroidEventProcessorTest.kt
@@ -66,7 +66,11 @@ class DefaultAndroidEventProcessorTest {
 
         lateinit var sentryTracer: SentryTracer
 
-        fun getSut(context: Context): DefaultAndroidEventProcessor {
+        fun getSut(
+            context: Context,
+            isSendDefaultPii: Boolean = false
+        ): DefaultAndroidEventProcessor {
+            options.isSendDefaultPii = isSendDefaultPii
             whenever(scopes.options).thenReturn(options)
             sentryTracer = SentryTracer(TransactionContext("", ""), scopes)
             return DefaultAndroidEventProcessor(context, buildInfo, options)
@@ -284,8 +288,20 @@ class DefaultAndroidEventProcessorTest {
     }
 
     @Test
-    fun `when event user data does not have ip address set, sets {{auto}} as the ip address`() {
-        val sut = fixture.getSut(context)
+    fun `when event user data does not have ip address set, sets no ip address if sendDefaultPii is false`() {
+        val sut = fixture.getSut(context, isSendDefaultPii = false)
+        val event = SentryEvent().apply {
+            user = User()
+        }
+        sut.process(event, Hint())
+        assertNotNull(event.user) {
+            assertNull(it.ipAddress)
+        }
+    }
+
+    @Test
+    fun `when event user data does not have ip address set, sets {{auto}} if sendDefaultPii is true`() {
+        val sut = fixture.getSut(context, isSendDefaultPii = true)
         val event = SentryEvent().apply {
             user = User()
         }
diff --git a/sentry/src/main/java/io/sentry/MainEventProcessor.java b/sentry/src/main/java/io/sentry/MainEventProcessor.java
index 50f11cba27..0e319845d6 100644
--- a/sentry/src/main/java/io/sentry/MainEventProcessor.java
+++ b/sentry/src/main/java/io/sentry/MainEventProcessor.java
@@ -248,7 +248,7 @@ private void mergeUser(final @NotNull SentryBaseEvent event) {
       user = new User();
       event.setUser(user);
     }
-    if (user.getIpAddress() == null) {
+    if (user.getIpAddress() == null && options.isSendDefaultPii()) {
       user.setIpAddress(IpAddressUtils.DEFAULT_IP_ADDRESS);
     }
   }
diff --git a/sentry/src/test/java/io/sentry/MainEventProcessorTest.kt b/sentry/src/test/java/io/sentry/MainEventProcessorTest.kt
index 3cb624d380..6ee8f19fe5 100644
--- a/sentry/src/test/java/io/sentry/MainEventProcessorTest.kt
+++ b/sentry/src/test/java/io/sentry/MainEventProcessorTest.kt
@@ -306,6 +306,16 @@ class MainEventProcessorTest {
         }
     }
 
+    @Test
+    fun `when event does not have ip address set, do not enrich ip address if sendDefaultPii is false`() {
+        val sut = fixture.getSut(sendDefaultPii = false)
+        val event = SentryEvent()
+        sut.process(event, Hint())
+        assertNotNull(event.user) {
+            assertNull(it.ipAddress)
+        }
+    }
+
     @Test
     fun `when event has ip address set, keeps original ip address`() {
         val sut = fixture.getSut(sendDefaultPii = true)

From 5989b29791b958aa9e63c93af4bc5533aa18cd30 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Tue, 21 Jan 2025 04:50:04 +0100
Subject: [PATCH 4/7] Merge v8 pre-release changelogs into one `8.0.0`
 changelog (#4066)

* merge changelog entries of pre releases

* modify changelog

* Update CHANGELOG.md

Co-authored-by: Lukas Bloder <lukas.bloder@gmail.com>

* review changes

* update changelog

* add auto ip change

* use previous self hosted version since we are no longer using is_exception_group

* more review comments

---------

Co-authored-by: Lukas Bloder <lukas.bloder@gmail.com>
---
 CHANGELOG.md | 524 +++++++++++++++++++--------------------------------
 1 file changed, 196 insertions(+), 328 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 93c0e14b38..00dbe2f7df 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,200 +2,30 @@
 
 ## Unreleased
 
-### Behavioural Changes
-
-- The user ip-address is now only set to `"{{auto}}"` if sendDefaultPii is enabled ([#4072](https://github.com/getsentry/sentry-java/pull/4072))
-    - This change gives you control over IP address collection directly on the client
-
-### Fixes
-
-- Do not set the exception group marker when there is a suppressed exception ([#4056](https://github.com/getsentry/sentry-java/pull/4056))
-  - Due to how grouping works in Sentry currently sometimes the suppressed exception is treated as the main exception. This change ensures we keep using the main exception and not change how grouping works.
-  - As a consequence the list of exceptions in the group on top of an issue is no longer shown in Sentry UI.
-  - We are planning to improve this in the future but opted for this fix first.
-
-### Internal
-
-- Make `SentryClient` constructor public ([#4045](https://github.com/getsentry/sentry-java/pull/4045))
-
-## 8.0.0-rc.4
-
-### Features
-
-- Enable `ThreadLocalAccessor` for Spring Boot 3 WebFlux by default ([#4023](https://github.com/getsentry/sentry-java/pull/4023))
-
-### Internal
-
-- Warm starts cleanup ([#3954](https://github.com/getsentry/sentry-java/pull/3954))
-
-### Dependencies
-
-- Bump Native SDK from v0.7.16 to v0.7.17 ([#4003](https://github.com/getsentry/sentry-java/pull/4003))
-    - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0717)
-    - [diff](https://github.com/getsentry/sentry-native/compare/0.7.16...0.7.17)
-
-## 8.0.0-rc.3
-
-### Features
-
-- Add `sentry-opentelemetry-agentless-spring` module ([#4000](https://github.com/getsentry/sentry-java/pull/4000))
-  - This module can be added as a dependency when using Sentry with OpenTelemetry and Spring Boot but don't want to use our Agent. It takes care of configuring OpenTelemetry for use with Sentry.
-  - You may want to set `OTEL_LOGS_EXPORTER=none;OTEL_METRICS_EXPORTER=none;OTEL_TRACES_EXPORTER=none` env vars to not have the log flooded with error messages regarding OpenTelemetry features we don't use.
-- Add `sentry-opentelemetry-agentless` module ([#3961](https://github.com/getsentry/sentry-java/pull/3961))
-  - This module can be added as a dependency when using Sentry with OpenTelemetry but don't want to use our Agent. It takes care of configuring OpenTelemetry for use with Sentry.
-  - To enable the auto configuration of it, please set `-Dotel.java.global-autoconfigure.enabled=true` on the `java` command, when starting your application.
-  - You may also want to set `OTEL_LOGS_EXPORTER=none;OTEL_METRICS_EXPORTER=none;OTEL_TRACES_EXPORTER=none` env vars to not have the log flooded with error messages regarding OpenTelemetry features we don't use.
-- `OpenTelemetryUtil.applyOpenTelemetryOptions` now takes an enum instead of a boolean for its mode
-- Add `openTelemetryMode` option ([#3994](https://github.com/getsentry/sentry-java/pull/3994))
-    - It defaults to `AUTO` meaning the SDK will figure out how to best configure itself for use with OpenTelemetry
-    - Use of OpenTelemetry can also be disabled completely by setting it to `OFF` ([#3995](https://github.com/getsentry/sentry-java/pull/3995))
-      - In this case even if OpenTelemetry is present, the Sentry SDK will not use it
-    - Use `AGENT` when using `sentry-opentelemetry-agent`
-    - Use `AGENTLESS` when using `sentry-opentelemetry-agentless`
-    - Use `AGENTLESS_SPRING` when using `sentry-opentelemetry-agentless-spring`
-- Add `scopeBindingMode` to `SpanOptions` ([#4004](https://github.com/getsentry/sentry-java/pull/4004))
-  - This setting only affects the SDK when used with OpenTelemetry.
-  - Defaults to `AUTO` meaning the SDK will decide whether the span should be bound to the current scope. It will not bind transactions to scope using `AUTO`, it will only bind spans where the parent span is on the current scope.
-  - `ON` sets the new span on the current scope.
-  - `OFF` does not set the new span on the scope.
-
-### Fixes
-
-- Replace deprecated `SimpleInstrumentation` with `SimplePerformantInstrumentation` for graphql 22 ([#3974](https://github.com/getsentry/sentry-java/pull/3974))
-- Cache requests for Spring using Springs `ContentCachingRequestWrapper` instead of our own Wrapper to also cache parameters ([#3641](https://github.com/getsentry/sentry-java/pull/3641))
-  - Previously only the body was cached which could lead to problems in the FilterChain as Request parameters were not available
-- We now hold a strong reference to the underlying OpenTelemetry span when it is created through Sentry API ([#3997](https://github.com/getsentry/sentry-java/pull/3997))
-  - This keeps it from being garbage collected too early
-- Close backpressure monitor on SDK shutdown ([#3998](https://github.com/getsentry/sentry-java/pull/3998))
-  - Due to the backpressure monitor rescheduling a task to run every 10s, it very likely caused shutdown to wait the full `shutdownTimeoutMillis` (defaulting to 2s) instead of being able to terminate immediately
-- Improve ignored check performance ([#3992](https://github.com/getsentry/sentry-java/pull/3992))
-  - Checking if a span origin, a transaction or a checkIn should be ignored is now faster
-
-## 8.0.0-rc.2
-
-### Fixes
-
-- Fix incoming defer sampling decision `sentry-trace` header ([#3942](https://github.com/getsentry/sentry-java/pull/3942))
-  - A `sentry-trace` header that only contains trace ID and span ID but no sampled flag (`-1`, `-0` suffix) means the receiving system can make its own sampling decision
-  - When generating `sentry-trace` header from `PropagationContext` we now copy the `sampled` flag.
-  - In `TransactionContext.fromPropagationContext` when there is no parent sampling decision, keep the decision `null` so a new sampling decision is made instead of defaulting to `false`
-- Defer sampling decision by setting `sampled` to `null` in `PropagationContext` when using OpenTelemetry in case of an incoming defer sampling `sentry-trace` header. ([#3945](https://github.com/getsentry/sentry-java/pull/3945))
-- Build `PropagationContext` from `SamplingDecision` made by `SentrySampler` instead of parsing headers and potentially ignoring a sampling decision in case a `sentry-trace` header comes in with deferred sampling decision. ([#3947](https://github.com/getsentry/sentry-java/pull/3947))
-- Let OpenTelemetry handle extracting and injecting tracing information ([#3953](https://github.com/getsentry/sentry-java/pull/3953))
-  - Our integrations no longer call `.continueTrace` and also do not inject tracing headers if the integration has been added to `ignoredSpanOrigins`
-
-## 8.0.0-rc.1
-
-### Features
-
-- Extract OpenTelemetry `URL_PATH` span attribute into description ([#3933](https://github.com/getsentry/sentry-java/pull/3933))
-- Replace OpenTelemetry `ContextStorage` wrapper with `ContextStorageProvider` ([#3938](https://github.com/getsentry/sentry-java/pull/3938))
-  - The wrapper had to be put in place before any call to `Context` whereas `ContextStorageProvider` is automatically invoked at the correct time.
-
-### Dependencies
-
-- Bump OpenTelemetry to 1.44.1, OpenTelemetry Java Agent to 2.10.0 and Semantic Conventions to 1.28.0 ([#3935](https://github.com/getsentry/sentry-java/pull/3935))
-
-### Fixes
-
-- Fix testTag not working for Jetpack Compose user interaction tracking ([#3878](https://github.com/getsentry/sentry-java/pull/3878))
-
-## 8.0.0-beta.3
-
-### Features
-
-- Send `otel.kind` to Sentry ([#3907](https://github.com/getsentry/sentry-java/pull/3907))
-- Allow passing `environment` to `CheckinUtils.withCheckIn` ([3889](https://github.com/getsentry/sentry-java/pull/3889))
-- Changes up to `7.18.0` have been merged and are now included as well
-
-### Fixes
-
-- Mark `DiskFlushNotification` hint flushed when rate limited ([#3892](https://github.com/getsentry/sentry-java/pull/3892))
-  - Our `UncaughtExceptionHandlerIntegration` waited for the full flush timeout duration (default 15s) when rate limited. 
-- Do not replace `op` with auto generated content for OpenTelemetry spans with span kind `INTERNAL` ([#3906](https://github.com/getsentry/sentry-java/pull/3906))
+Version 8 of the Sentry Android/Java SDK brings a variety of features and fixes. The most notable changes are:
 
-### Behavioural Changes
+- `Hub` has been replaced by `Scopes`
+- New `Scope` types have been introduced, see "Behavioural Changes" for more details.
+- Lifecycle tokens have been introduced to manage `Scope` lifecycle, see "Behavioural Changes" for more details.
+- Bumping `minSdk` level to 21 (Android 5.0)
+- Our `sentry-opentelemetry-agent` has been improved and now works in combination with the rest of Sentry. You may now mix and match OpenTelemetry and Sentry API for instrumenting your application.
+- The SDK is now compatible with Spring Boot 3.4
+- We now support GraphQL v22 (`sentry-graphql-22`)
+- Metrics have been removed
 
-- Send file name and path only if isSendDefaultPii is true ([#3919](https://github.com/getsentry/sentry-java/pull/3919))
+### Sentry Self-hosted Compatibility
 
-## 8.0.0-beta.2
+This SDK version is compatible with a self-hosted version of Sentry `22.12.0` or higher. If you are using an older version of [self-hosted Sentry](https://develop.sentry.dev/self-hosted/) (aka onpremise), you will need to [upgrade](https://develop.sentry.dev/self-hosted/releases/). If you're using `sentry.io` no action is required.
 
 ### Breaking Changes
 
-- Use String instead of UUID for SessionId ([#3834](https://github.com/getsentry/sentry-java/pull/3834))
-  - The `Session` constructor now takes a `String` instead of a `UUID` for the `sessionId` parameter.
-  - `Session.getSessionId()` now returns a `String` instead of a `UUID`.
 - The Android minSdk level for all Android modules is now 21 ([#3852](https://github.com/getsentry/sentry-java/pull/3852))
 - The minSdk level for sentry-android-ndk changed from 19 to 21 ([#3851](https://github.com/getsentry/sentry-java/pull/3851))
-- All status codes below 400 are now mapped to `SpanStatus.OK` ([#3869](https://github.com/getsentry/sentry-java/pull/3869))
-
-### Features
-
-- Spring Boot now automatically detects if OpenTelemetry is available and makes use of it ([#3846](https://github.com/getsentry/sentry-java/pull/3846))
-  - This is only enabled if there is no OpenTelemetry agent available
-  - We prefer to use the OpenTelemetry agent as it offers more auto instrumentation
-  - In some cases the OpenTelemetry agent cannot be used, please see https://opentelemetry.io/docs/zero-code/java/spring-boot-starter/ for more details on when to prefer the Agent and when the Spring Boot starter makes more sense.
-  - In this mode the SDK makes use of the `OpenTelemetry` bean that is created by `opentelemetry-spring-boot-starter` instead of `GlobalOpenTelemetry`
-- Spring Boot now automatically detects our OpenTelemetry agent if its auto init is disabled ([#3848](https://github.com/getsentry/sentry-java/pull/3848))
-  - This means Spring Boot config mechanisms can now be combined with our OpenTelemetry agent
-  - The `sentry-opentelemetry-extra` module has been removed again, most classes have been moved to `sentry-opentelemetry-bootstrap` which is loaded into the bootstrap classloader (i.e. `null`) when our Java agent is used. The rest has been moved into `sentry-opentelemetry-agentcustomization` and is loaded into the agent classloader when our Java agent is used.
-  - The `sentry-opentelemetry-bootstrap` and `sentry-opentelemetry-agentcustomization` modules can be used without the agent as well, in which case all classes are loaded into the application classloader. Check out our `sentry-samples-spring-boot-jakarta-opentelemetry-noagent` sample.
-  - In this mode the SDK makes use of `GlobalOpenTelemetry`
-- Automatically set span factory based on presence of OpenTelemetry ([#3858](https://github.com/getsentry/sentry-java/pull/3858))
-  - `SentrySpanFactoryHolder` has been removed as it is no longer required.
-- Add `ignoredTransactions` option to filter out transactions by name ([#3871](https://github.com/getsentry/sentry-java/pull/3871))
-  - can be used via ENV vars, e.g. `SENTRY_IGNORED_TRANSACTIONS=POST /person/,GET /pers.*`
-  - can also be set in options directly, e.g. `options.setIgnoredTransactions(...)`
-  - can also be set in `sentry.properties`, e.g. `ignored-transactions=POST /person/,GET /pers.*`
-  - can also be set in Spring config `application.properties`, e.g. `sentry.ignored-transactions=POST /person/,GET /pers.*`
-- Add a sample for showcasing Sentry with OpenTelemetry for Spring Boot 3 with our Java agent (`sentry-samples-spring-boot-jakarta-opentelemetry`) ([#3856](https://github.com/getsentry/sentry-java/pull/3828))
-- Add a sample for showcasing Sentry with OpenTelemetry for Spring Boot 3 without our Java agent (`sentry-samples-spring-boot-jakarta-opentelemetry-noagent`) ([#3856](https://github.com/getsentry/sentry-java/pull/3856))
-- Add a sample for showcasing Sentry with OpenTelemetry (`sentry-samples-console-opentelemetry-noagent`) ([#3856](https://github.com/getsentry/sentry-java/pull/3862))
-- Add `globalHubMode` to options ([#3805](https://github.com/getsentry/sentry-java/pull/3805))
-  - `globalHubMode` used to only be a param on `Sentry.init`. To make it easier to be used in e.g. Desktop environments, we now additionally added it as an option on SentryOptions that can also be set via `sentry.properties`.
-  - If both the param on `Sentry.init` and the option are set, the option will win. By default the option is set to `null` meaning whatever is passed to `Sentry.init` takes effect.
-- Lazy uuid generation for SentryId and SpanId ([#3770](https://github.com/getsentry/sentry-java/pull/3770))
-- Faster generation of Sentry and Span IDs ([#3818](https://github.com/getsentry/sentry-java/pull/3818))
-  - Uses faster implementation to convert UUID to SentryID String
-  - Uses faster Random implementation to generate UUIDs
-- Android 15: Add support for 16KB page sizes ([#3851](https://github.com/getsentry/sentry-java/pull/3851))
-  - See https://developer.android.com/guide/practices/page-sizes for more details
-- Changes up to `7.17.0` have been merged and are now included as well
-
-### Fixes
-
-- The Sentry OpenTelemetry Java agent now makes sure Sentry `Scopes` storage is initialized even if the agents auto init is disabled ([#3848](https://github.com/getsentry/sentry-java/pull/3848))
-  - This is required for all integrations to work together with our OpenTelemetry Java agent if its auto init has been disabled and the SDKs init should be used instead.
-- Do not ignore certain span origins for OpenTelemetry without agent ([#3856](https://github.com/getsentry/sentry-java/pull/3856))
-- Fix `startChild` for span that is not in current OpenTelemetry `Context` ([#3862](https://github.com/getsentry/sentry-java/pull/3862))
-  - Starting a child span from a transaction that wasn't in the current `Context` lead to multiple transactions being created (one for the transaction and another per span created).
-- Add `auto.graphql.graphql22` to ignored span origins when using OpenTelemetry ([#3828](https://github.com/getsentry/sentry-java/pull/3828))
-- The Spring Boot 3 WebFlux sample now uses our GraphQL v22 integration ([#3828](https://github.com/getsentry/sentry-java/pull/3828))
-- All status codes below 400 are now mapped to `SpanStatus.OK` ([#3869](https://github.com/getsentry/sentry-java/pull/3869))
-
-
-### Dependencies
-
-- Bump Native SDK from v0.7.5 to v0.7.14 ([#3851](https://github.com/getsentry/sentry-java/pull/3851)) ([#3914](https://github.com/getsentry/sentry-java/pull/3914))
-    - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0714)
-    - [diff](https://github.com/getsentry/sentry-native/compare/0.7.5...0.7.14)
-
-### Behavioural Changes
-
-- (Android) Enable Performance V2 by default ([#3824](https://github.com/getsentry/sentry-java/pull/3824))
-  - With this change cold app start spans will include spans for ContentProviders, Application and Activity load.
-
-## 8.0.0-beta.1
-
-### Breaking Changes
-
 - Throw IllegalArgumentException when calling Sentry.init on Android ([#3596](https://github.com/getsentry/sentry-java/pull/3596))
 - Metrics have been removed from the SDK ([#3774](https://github.com/getsentry/sentry-java/pull/3774))
     - Metrics will return but we don't know in what exact form yet
 - `enableTracing` option (a.k.a `enable-tracing`) has been removed from the SDK ([#3776](https://github.com/getsentry/sentry-java/pull/3776))
     - Please set `tracesSampleRate` to a value >= 0.0 for enabling performance instead. The default value is `null` which means performance is disabled.
-- Change OkHttp sub-spans to span attributes ([#3556](https://github.com/getsentry/sentry-java/pull/3556))
-    - This will reduce the number of spans created by the SDK
 - Replace `synchronized` methods and blocks with `ReentrantLock` (`AutoClosableReentrantLock`) ([#3715](https://github.com/getsentry/sentry-java/pull/3715))
     - If you are subclassing any Sentry classes, please check if the parent class used `synchronized` before. Please make sure to use the same lock object as the parent class in that case.
 - `traceOrigins` option (`io.sentry.traces.tracing-origins` in manifest) has been removed, please use `tracePropagationTargets` (`io.sentry.traces.trace-propagation-targets` in manifest`) instead ([#3780](https://github.com/getsentry/sentry-java/pull/3780))
@@ -212,10 +42,102 @@
 - `TraceContext.user` and `TraceContextUser` class have been removed, please use `userId` on `TraceContext` instead ([#3780](https://github.com/getsentry/sentry-java/pull/3780))
 - `TransactionContext.fromSentryTrace()` has been removed, please use `Sentry.continueTrace()` instead ([#3780](https://github.com/getsentry/sentry-java/pull/3780))
 - `SentryDataFetcherExceptionHandler` has been removed, please use `SentryGenericDataFetcherExceptionHandler` in combination with `SentryInstrumentation` instead ([#3780](https://github.com/getsentry/sentry-java/pull/3780))
+- `sentry-android-okhttp` has been removed in favor of `sentry-okhttp`, removing android dependency from the module ([#3510](https://github.com/getsentry/sentry-java/pull/3510))
+- `Contexts` no longer extends `ConcurrentHashMap`, instead we offer a selected set of methods.
+- User segment has been removed ([#3512](https://github.com/getsentry/sentry-java/pull/3512))
 - One of the `AndroidTransactionProfiler` constructors has been removed, please use a different one ([#3780](https://github.com/getsentry/sentry-java/pull/3780))
+- Use String instead of UUID for SessionId ([#3834](https://github.com/getsentry/sentry-java/pull/3834))
+    - The `Session` constructor now takes a `String` instead of a `UUID` for the `sessionId` parameter.
+    - `Session.getSessionId()` now returns a `String` instead of a `UUID`.
+- All status codes below 400 are now mapped to `SpanStatus.OK` ([#3869](https://github.com/getsentry/sentry-java/pull/3869))
+- Change OkHttp sub-spans to span attributes ([#3556](https://github.com/getsentry/sentry-java/pull/3556))
+    - This will reduce the number of spans created by the SDK
+- `instrumenter` option should no longer be needed as our new OpenTelemetry integration now works in combination with the rest of Sentry
+
+### Behavioural Changes
+
+- We're introducing some new `Scope` types in the SDK, allowing for better control over what data is attached where. Previously there was a stack of scopes that was pushed and popped. Instead we now fork scopes for a given lifecycle and then restore the previous scopes. Since `Hub` is gone, it is also never cloned anymore. Separation of data now happens through the different scope types while making it easier to manipulate exactly what you need without having to attach data at the right time to have it apply where wanted.
+    - Global scope is attached to all events created by the SDK. It can also be modified before `Sentry.init` has been called. It can be manipulated using `Sentry.configureScope(ScopeType.GLOBAL, (scope) -> { ... })`.
+    - Isolation scope can be used e.g. to attach data to all events that come up while handling an incoming request. It can also be used for other isolation purposes. It can be manipulated using `Sentry.configureScope(ScopeType.ISOLATION, (scope) -> { ... })`. The SDK automatically forks isolation scope in certain cases like incoming requests, CRON jobs, Spring `@Async` and more.
+    - Current scope is forked often and data added to it is only added to events that are created while this scope is active. Data is also passed on to newly forked child scopes but not to parents. It can be manipulated using `Sentry.configureScope(ScopeType.CURRENT, (scope) -> { ... })`.
+- `Sentry.popScope` has been deprecated, please call `.close()` on the token returned by `Sentry.pushScope` instead or use it in a way described in more detail in "Migration Guide".
+- We have chosen a default scope that is used for `Sentry.configureScope()` as well as API like `Sentry.setTag()`
+    - For Android the type defaults to `CURRENT` scope
+    - For Backend and other JVM applicatons it defaults to `ISOLATION` scope
+- Event processors on `Scope` can now be ordered by overriding the `getOrder` method on implementations of `EventProcessor`. NOTE: This order only applies to event processors on `Scope` but not `SentryOptions` at the moment. Feel free to request this if you need it.
+- `Hub` is deprecated in favor of `Scopes`, alongside some `Hub` relevant APIs. More details can be found in the "Migration Guide" section.
+- Send file name and path only if `isSendDefaultPii` is `true` ([#3919](https://github.com/getsentry/sentry-java/pull/3919))
+- (Android) Enable Performance V2 by default ([#3824](https://github.com/getsentry/sentry-java/pull/3824))
+    - With this change cold app start spans will include spans for ContentProviders, Application and Activity load.
+- (Android) Replace thread id with kernel thread id in span data ([#3706](https://github.com/getsentry/sentry-java/pull/3706))
+- (Android) The JNI layer for sentry-native has now been moved from sentry-java to sentry-native ([#3189](https://github.com/getsentry/sentry-java/pull/3189))
+    - This now includes prefab support for sentry-native, allowing you to link and access the sentry-native API within your native app code
+    - Checkout the `sentry-samples/sentry-samples-android` example on how to configure CMake and consume `sentry.h`
+- The user ip-address is now only set to `"{{auto}}"` if `sendDefaultPii` is enabled ([#4072](https://github.com/getsentry/sentry-java/pull/4072))
+  - This change gives you control over IP address collection directly on the client
 
 ### Features
 
+- The SDK is now compatible with Spring Boot 3.4 ([#3939](https://github.com/getsentry/sentry-java/pull/3939))
+- Our `sentry-opentelemetry-agent` has been completely reworked and now plays nicely with the rest of the Java SDK
+    - You may also want to give this new agent a try even if you haven't used OpenTelemetry (with Sentry) before. It offers support for [many more libraries and frameworks](https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/main/docs/supported-libraries.md), improving on our trace propagation, `Scopes` (used to be `Hub`) propagation as well as performance instrumentation (i.e. more spans).
+    - If you are using a framework we did not support before and currently resort to manual instrumentation, please give the agent a try. See [here for a list of supported libraries, frameworks and application servers](https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/main/docs/supported-libraries.md).
+    - Please see [Java SDK docs](https://docs.sentry.io/platforms/java/tracing/instrumentation/opentelemetry/) for more details on how to set up the agent. Please make sure to select the correct SDK from the dropdown on the left side of the docs.
+    - What's new about the Agent
+        - When the OpenTelemetry Agent is used, Sentry API creates OpenTelemetry spans under the hood, handing back a wrapper object which bridges the gap between traditional Sentry API and OpenTelemetry. We might be replacing some of the Sentry performance API in the future.
+            - This is achieved by configuring the SDK to use `OtelSpanFactory` instead of `DefaultSpanFactory` which is done automatically by the auto init of the Java Agent.
+        - OpenTelemetry spans are now only turned into Sentry spans when they are finished so they can be sent to the Sentry server.
+        - Now registers an OpenTelemetry `Sampler` which uses Sentry sampling configuration
+        - Other Performance integrations automatically stop creating spans to avoid duplicate spans
+        - The Sentry SDK now makes use of OpenTelemetry `Context` for storing Sentry `Scopes` (which is similar to what used to be called `Hub`) and thus relies on OpenTelemetry for `Context` propagation.
+        - Classes used for the previous version of our OpenTelemetry support have been deprecated but can still be used manually. We're not planning to keep the old agent around in favor of less complexity in the SDK.
+- Add `sentry-opentelemetry-agentless-spring` module ([#4000](https://github.com/getsentry/sentry-java/pull/4000))
+    - This module can be added as a dependency when using Sentry with OpenTelemetry and Spring Boot but don't want to use our Agent. It takes care of configuring OpenTelemetry for use with Sentry.
+    - You may want to set `OTEL_LOGS_EXPORTER=none;OTEL_METRICS_EXPORTER=none;OTEL_TRACES_EXPORTER=none` env vars to not have the log flooded with error messages regarding OpenTelemetry features we don't use.
+- Add `sentry-opentelemetry-agentless` module ([#3961](https://github.com/getsentry/sentry-java/pull/3961))
+    - This module can be added as a dependency when using Sentry with OpenTelemetry but don't want to use our Agent. It takes care of configuring OpenTelemetry for use with Sentry.
+    - To enable the auto configuration of it, please set `-Dotel.java.global-autoconfigure.enabled=true` on the `java` command, when starting your application.
+    - You may also want to set `OTEL_LOGS_EXPORTER=none;OTEL_METRICS_EXPORTER=none;OTEL_TRACES_EXPORTER=none` env vars to not have the log flooded with error messages regarding OpenTelemetry features we don't use.
+- `OpenTelemetryUtil.applyOpenTelemetryOptions` now takes an enum instead of a boolean for its mode
+- Add `openTelemetryMode` option ([#3994](https://github.com/getsentry/sentry-java/pull/3994))
+    - It defaults to `AUTO` meaning the SDK will figure out how to best configure itself for use with OpenTelemetry
+    - Use of OpenTelemetry can also be disabled completely by setting it to `OFF` ([#3995](https://github.com/getsentry/sentry-java/pull/3995))
+        - In this case even if OpenTelemetry is present, the Sentry SDK will not use it
+    - Use `AGENT` when using `sentry-opentelemetry-agent`
+    - Use `AGENTLESS` when using `sentry-opentelemetry-agentless`
+    - Use `AGENTLESS_SPRING` when using `sentry-opentelemetry-agentless-spring`
+- Add `ignoredTransactions` option to filter out transactions by name ([#3871](https://github.com/getsentry/sentry-java/pull/3871))
+    - can be used via ENV vars, e.g. `SENTRY_IGNORED_TRANSACTIONS=POST /person/,GET /pers.*`
+    - can also be set in options directly, e.g. `options.setIgnoredTransactions(...)`
+    - can also be set in `sentry.properties`, e.g. `ignored-transactions=POST /person/,GET /pers.*`
+    - can also be set in Spring config `application.properties`, e.g. `sentry.ignored-transactions=POST /person/,GET /pers.*`
+- Add `scopeBindingMode` to `SpanOptions` ([#4004](https://github.com/getsentry/sentry-java/pull/4004))
+    - This setting only affects the SDK when used with OpenTelemetry.
+    - Defaults to `AUTO` meaning the SDK will decide whether the span should be bound to the current scope. It will not bind transactions to scope using `AUTO`, it will only bind spans where the parent span is on the current scope.
+    - `ON` sets the new span on the current scope.
+    - `OFF` does not set the new span on the scope.
+- Add `ignoredSpanOrigins` option for ignoring spans coming from certain integrations
+    - We pre-configure this to ignore Performance instrumentation for Spring and other integrations when using our OpenTelemetry Agent to avoid duplicate spans
+- Support `graphql-java` v22 via a new module `sentry-graphql-22` ([#3740](https://github.com/getsentry/sentry-java/pull/3740))
+    - If you are using `graphql-java` v21 or earlier, you can use the `sentry-graphql` module
+    - For `graphql-java` v22 and newer please use the `sentry-graphql-22` module
+- We now provide a `SentryInstrumenter` bean directly for Spring (Boot) if there is none yet instead of using `GraphQlSourceBuilderCustomizer` to add the instrumentation ([#3744](https://github.com/getsentry/sentry-java/pull/3744))
+    - It is now also possible to provide a bean of type `SentryGraphqlInstrumentation.BeforeSpanCallback` which is then used by `SentryInstrumenter`
+- Add data fetching environment hint to breadcrumb for GraphQL (#3413) ([#3431](https://github.com/getsentry/sentry-java/pull/3431))
+- Report exceptions returned by Throwable.getSuppressed() to Sentry as exception groups ([#3396] https://github.com/getsentry/sentry-java/pull/3396)
+  - Any suppressed exceptions are added to the issue details page in Sentry, the same way any cause is.
+  - We are planning to improve how we visualize suppressed exceptions. See https://github.com/getsentry/sentry-java/issues/4059
+- Enable `ThreadLocalAccessor` for Spring Boot 3 WebFlux by default ([#4023](https://github.com/getsentry/sentry-java/pull/4023))
+- Allow passing `environment` to `CheckinUtils.withCheckIn` ([3889](https://github.com/getsentry/sentry-java/pull/3889))
+- Add `globalHubMode` to options ([#3805](https://github.com/getsentry/sentry-java/pull/3805))
+    - `globalHubMode` used to only be a param on `Sentry.init`. To make it easier to be used in e.g. Desktop environments, we now additionally added it as an option on SentryOptions that can also be set via `sentry.properties`.
+    - If both the param on `Sentry.init` and the option are set, the option will win. By default the option is set to `null` meaning whatever is passed to `Sentry.init` takes effect.
+- Lazy uuid generation for SentryId and SpanId ([#3770](https://github.com/getsentry/sentry-java/pull/3770))
+- Faster generation of Sentry and Span IDs ([#3818](https://github.com/getsentry/sentry-java/pull/3818))
+    - Uses faster implementation to convert UUID to SentryID String
+    - Uses faster Random implementation to generate UUIDs
+- Android 15: Add support for 16KB page sizes ([#3851](https://github.com/getsentry/sentry-java/pull/3851))
+    - See https://developer.android.com/guide/practices/page-sizes for more details
 - Add init priority settings ([#3674](https://github.com/getsentry/sentry-java/pull/3674))
     - You may now set `forceInit=true` (`force-init` for `.properties` files) to ensure a call to Sentry.init / SentryAndroid.init takes effect
 - Add force init option to Android Manifest ([#3675](https://github.com/getsentry/sentry-java/pull/3675))
@@ -223,183 +145,119 @@
 - Attach request body for `application/x-www-form-urlencoded` requests in Spring ([#3731](https://github.com/getsentry/sentry-java/pull/3731))
     - Previously request body was only attached for `application/json` requests
 - Set breadcrumb level based on http status ([#3771](https://github.com/getsentry/sentry-java/pull/3771))
-- Support `graphql-java` v22 via a new module `sentry-graphql-22` ([#3740](https://github.com/getsentry/sentry-java/pull/3740))
-    - If you are using `graphql-java` v21 or earlier, you can use the `sentry-graphql` module
-    - For `graphql-java` v22 and newer please use the `sentry-graphql-22` module
-- We now provide a `SentryInstrumenter` bean directly for Spring (Boot) if there is none yet instead of using `GraphQlSourceBuilderCustomizer` to add the instrumentation ([#3744](https://github.com/getsentry/sentry-java/pull/3744))
-    - It is now also possible to provide a bean of type `SentryGraphqlInstrumentation.BeforeSpanCallback` which is then used by `SentryInstrumenter`
 - Emit transaction.data inside contexts.trace.data ([#3735](https://github.com/getsentry/sentry-java/pull/3735))
-  - Also does not emit `transaction.data` in `exras` anymore
+    - Also does not emit `transaction.data` in `exras` anymore
+- Add a sample for showcasing Sentry with OpenTelemetry for Spring Boot 3 with our Java agent (`sentry-samples-spring-boot-jakarta-opentelemetry`) ([#3856](https://github.com/getsentry/sentry-java/pull/3828))
+- Add a sample for showcasing Sentry with OpenTelemetry for Spring Boot 3 without our Java agent (`sentry-samples-spring-boot-jakarta-opentelemetry-noagent`) ([#3856](https://github.com/getsentry/sentry-java/pull/3856))
+- Add a sample for showcasing Sentry with OpenTelemetry (`sentry-samples-console-opentelemetry-noagent`) ([#3856](https://github.com/getsentry/sentry-java/pull/3862))
 
 ### Fixes
 
-- Use OpenTelemetry span name as fallback for transaction name ([#3557](https://github.com/getsentry/sentry-java/pull/3557))
-    - In certain cases we were sending transactions as "<unlabeled transaction>" when using OpenTelemetry
-- Add OpenTelemetry span data to Sentry span ([#3593](https://github.com/getsentry/sentry-java/pull/3593))
-- No longer selectively copy OpenTelemetry attributes to Sentry spans / transactions `data` ([#3663](https://github.com/getsentry/sentry-java/pull/3663))
-- Remove `PROCESS_COMMAND_ARGS` (`process.command_args`) OpenTelemetry span attribute as it can be very large ([#3664](https://github.com/getsentry/sentry-java/pull/3664))
-- Use RECORD_ONLY sampling decision if performance is disabled ([#3659](https://github.com/getsentry/sentry-java/pull/3659))
-    - Also fix check whether Performance is enabled when making a sampling decision in the OpenTelemetry sampler
-- Sentry OpenTelemetry Java Agent now sets Instrumenter to SENTRY (used to be OTEL) ([#3697](https://github.com/getsentry/sentry-java/pull/3697))
-- Set span origin in `ActivityLifecycleIntegration` on span options instead of after creating the span / transaction ([#3702](https://github.com/getsentry/sentry-java/pull/3702))
-    - This allows spans to be filtered by span origin on creation
-- Honor ignored span origins in `SentryTracer.startChild` ([#3704](https://github.com/getsentry/sentry-java/pull/3704))
+- Fix incoming defer sampling decision `sentry-trace` header ([#3942](https://github.com/getsentry/sentry-java/pull/3942))
+    - A `sentry-trace` header that only contains trace ID and span ID but no sampled flag (`-1`, `-0` suffix) means the receiving system can make its own sampling decision
+    - When generating `sentry-trace` header from `PropagationContext` we now copy the `sampled` flag.
+    - In `TransactionContext.fromPropagationContext` when there is no parent sampling decision, keep the decision `null` so a new sampling decision is made instead of defaulting to `false`
+- Fix order of calling `close` on previous Sentry instance when re-initializing ([#3750](https://github.com/getsentry/sentry-java/pull/3750))
+    - Previously some parts of Sentry were immediately closed after re-init that should have stayed open and some parts of the previous init were never closed
+- All status codes below 400 are now mapped to `SpanStatus.OK` ([#3869](https://github.com/getsentry/sentry-java/pull/3869))
+- Improve ignored check performance ([#3992](https://github.com/getsentry/sentry-java/pull/3992))
+    - Checking if a span origin, a transaction or a checkIn should be ignored is now faster
+- Cache requests for Spring using Springs `ContentCachingRequestWrapper` instead of our own Wrapper to also cache parameters ([#3641](https://github.com/getsentry/sentry-java/pull/3641))
+    - Previously only the body was cached which could lead to problems in the FilterChain as Request parameters were not available
+- Close backpressure monitor on SDK shutdown ([#3998](https://github.com/getsentry/sentry-java/pull/3998))
+    - Due to the backpressure monitor rescheduling a task to run every 10s, it very likely caused shutdown to wait the full `shutdownTimeoutMillis` (defaulting to 2s) instead of being able to terminate immediately
+- Let OpenTelemetry auto instrumentation handle extracting and injecting tracing information if present ([#3953](https://github.com/getsentry/sentry-java/pull/3953))
+    - Our integrations no longer call `.continueTrace` and also do not inject tracing headers if the integration has been added to `ignoredSpanOrigins`
+- Fix testTag not working for Jetpack Compose user interaction tracking ([#3878](https://github.com/getsentry/sentry-java/pull/3878))
+- Mark `DiskFlushNotification` hint flushed when rate limited ([#3892](https://github.com/getsentry/sentry-java/pull/3892))
+    - Our `UncaughtExceptionHandlerIntegration` waited for the full flush timeout duration (default 15s) when rate limited.
+- Do not replace `op` with auto generated content for OpenTelemetry spans with span kind `INTERNAL` ([#3906](https://github.com/getsentry/sentry-java/pull/3906))
 - Add `enable-spotlight` and `spotlight-connection-url` to external options and check if spotlight is enabled when deciding whether to inspect an OpenTelemetry span for connecting to splotlight ([#3709](https://github.com/getsentry/sentry-java/pull/3709))
 - Trace context on `Contexts.setTrace` has been marked `@NotNull` ([#3721](https://github.com/getsentry/sentry-java/pull/3721))
     - Setting it to `null` would cause an exception.
     - Transactions are dropped if trace context is missing
 - Remove internal annotation on `SpanOptions` ([#3722](https://github.com/getsentry/sentry-java/pull/3722))
 - `SentryLogbackInitializer` is now public ([#3723](https://github.com/getsentry/sentry-java/pull/3723))
-- Fix order of calling `close` on previous Sentry instance when re-initializing ([#3750](https://github.com/getsentry/sentry-java/pull/3750))
-    - Previously some parts of Sentry were immediately closed after re-init that should have stayed open and some parts of the previous init were never closed
-
-### Behavioural Changes
+- Parse and use `send-default-pii` and `max-request-body-size` from `sentry.properties` ([#3534](https://github.com/getsentry/sentry-java/pull/3534))
+- `TracesSampler` is now only created once in `SentryOptions` instead of creating a new one for every `Hub` (which is now `Scopes`). This means we're now creating fewer `SecureRandom` instances.
 
-- (Android) Replace thread id with kernel thread id in span data ([#3706](https://github.com/getsentry/sentry-java/pull/3706))
+### Internal
 
-### Dependencies
+- Make `SentryClient` constructor public ([#4045](https://github.com/getsentry/sentry-java/pull/4045))
+- Warm starts cleanup ([#3954](https://github.com/getsentry/sentry-java/pull/3954))
 
-- Bump OpenTelemetry to 1.41.0, OpenTelemetry Java Agent to 2.7.0 and Semantic Conventions to 1.25.0 ([#3668](https://github.com/getsentry/sentry-java/pull/3668))
+### Changes in pre-releases
 
-## 8.0.0-alpha.4
+These changes have been made during development of `8.0.0`. You may skip this section. We just put it here for sake of completeness.
 
-### Fixes
+- Extract OpenTelemetry `URL_PATH` span attribute into description ([#3933](https://github.com/getsentry/sentry-java/pull/3933))
+- Replace OpenTelemetry `ContextStorage` wrapper with `ContextStorageProvider` ([#3938](https://github.com/getsentry/sentry-java/pull/3938))
+    - The wrapper had to be put in place before any call to `Context` whereas `ContextStorageProvider` is automatically invoked at the correct time.
+- Send `otel.kind` to Sentry ([#3907](https://github.com/getsentry/sentry-java/pull/3907))
+- Spring Boot now automatically detects if OpenTelemetry is available and makes use of it ([#3846](https://github.com/getsentry/sentry-java/pull/3846))
+    - This is only enabled if there is no OpenTelemetry agent available
+    - We prefer to use the OpenTelemetry agent as it offers more auto instrumentation
+    - In some cases the OpenTelemetry agent cannot be used, please see https://opentelemetry.io/docs/zero-code/java/spring-boot-starter/ for more details on when to prefer the Agent and when the Spring Boot starter makes more sense.
+    - In this mode the SDK makes use of the `OpenTelemetry` bean that is created by `opentelemetry-spring-boot-starter` instead of `GlobalOpenTelemetry`
+- Spring Boot now automatically detects our OpenTelemetry agent if its auto init is disabled ([#3848](https://github.com/getsentry/sentry-java/pull/3848))
+    - This means Spring Boot config mechanisms can now be combined with our OpenTelemetry agent
+    - The `sentry-opentelemetry-extra` module has been removed again, most classes have been moved to `sentry-opentelemetry-bootstrap` which is loaded into the bootstrap classloader (i.e. `null`) when our Java agent is used. The rest has been moved into `sentry-opentelemetry-agentcustomization` and is loaded into the agent classloader when our Java agent is used.
+    - The `sentry-opentelemetry-bootstrap` and `sentry-opentelemetry-agentcustomization` modules can be used without the agent as well, in which case all classes are loaded into the application classloader. Check out our `sentry-samples-spring-boot-jakarta-opentelemetry-noagent` sample.
+    - In this mode the SDK makes use of `GlobalOpenTelemetry`
+- Automatically set span factory based on presence of OpenTelemetry ([#3858](https://github.com/getsentry/sentry-java/pull/3858))
+    - `SentrySpanFactoryHolder` has been removed as it is no longer required.
 
-- Removed user segment ([#3512](https://github.com/getsentry/sentry-java/pull/3512))
+- Replace deprecated `SimpleInstrumentation` with `SimplePerformantInstrumentation` for graphql 22 ([#3974](https://github.com/getsentry/sentry-java/pull/3974))
+- We now hold a strong reference to the underlying OpenTelemetry span when it is created through Sentry API ([#3997](https://github.com/getsentry/sentry-java/pull/3997))
+    - This keeps it from being garbage collected too early
+- Defer sampling decision by setting `sampled` to `null` in `PropagationContext` when using OpenTelemetry in case of an incoming defer sampling `sentry-trace` header. ([#3945](https://github.com/getsentry/sentry-java/pull/3945))
+- Build `PropagationContext` from `SamplingDecision` made by `SentrySampler` instead of parsing headers and potentially ignoring a sampling decision in case a `sentry-trace` header comes in with deferred sampling decision. ([#3947](https://github.com/getsentry/sentry-java/pull/3947))
+- The Sentry OpenTelemetry Java agent now makes sure Sentry `Scopes` storage is initialized even if the agents auto init is disabled ([#3848](https://github.com/getsentry/sentry-java/pull/3848))
+    - This is required for all integrations to work together with our OpenTelemetry Java agent if its auto init has been disabled and the SDKs init should be used instead.
+- Fix `startChild` for span that is not in current OpenTelemetry `Context` ([#3862](https://github.com/getsentry/sentry-java/pull/3862))
+    - Starting a child span from a transaction that wasn't in the current `Context` lead to multiple transactions being created (one for the transaction and another per span created).
+- Add `auto.graphql.graphql22` to ignored span origins when using OpenTelemetry ([#3828](https://github.com/getsentry/sentry-java/pull/3828))
+- Use OpenTelemetry span name as fallback for transaction name ([#3557](https://github.com/getsentry/sentry-java/pull/3557))
+    - In certain cases we were sending transactions as "<unlabeled transaction>" when using OpenTelemetry
+- Add OpenTelemetry span data to Sentry span ([#3593](https://github.com/getsentry/sentry-java/pull/3593))
+- No longer selectively copy OpenTelemetry attributes to Sentry spans / transactions `data` ([#3663](https://github.com/getsentry/sentry-java/pull/3663))
+- Remove `PROCESS_COMMAND_ARGS` (`process.command_args`) OpenTelemetry span attribute as it can be very large ([#3664](https://github.com/getsentry/sentry-java/pull/3664))
+- Use RECORD_ONLY sampling decision if performance is disabled ([#3659](https://github.com/getsentry/sentry-java/pull/3659))
+    - Also fix check whether Performance is enabled when making a sampling decision in the OpenTelemetry sampler
+- Sentry OpenTelemetry Java Agent now sets Instrumenter to SENTRY (used to be OTEL) ([#3697](https://github.com/getsentry/sentry-java/pull/3697))
+- Set span origin in `ActivityLifecycleIntegration` on span options instead of after creating the span / transaction ([#3702](https://github.com/getsentry/sentry-java/pull/3702))
+    - This allows spans to be filtered by span origin on creation
+- Honor ignored span origins in `SentryTracer.startChild` ([#3704](https://github.com/getsentry/sentry-java/pull/3704))
 - Use span id of remote parent ([#3548](https://github.com/getsentry/sentry-java/pull/3548))
     - Traces were broken because on an incoming request, OtelSentrySpanProcessor did not set the parentSpanId on the span correctly. Traces were not referencing the actual parent span but some other (random) span ID which the server doesn't know.
 - Attach active span to scope when using OpenTelemetry ([#3549](https://github.com/getsentry/sentry-java/pull/3549))
     - Errors weren't linked to traces correctly due to parts of the SDK not knowing the current span
 - Record dropped spans in client report when sampling out OpenTelemetry spans ([#3552](https://github.com/getsentry/sentry-java/pull/3552))
 - Retrieve the correct current span from `Scope`/`Scopes` when using OpenTelemetry ([#3554](https://github.com/getsentry/sentry-java/pull/3554))
-
-## 8.0.0-alpha.3
-
-### Breaking Changes
-
-- `sentry-android-okhttp` has been removed in favor of `sentry-okhttp`, removing android dependency from the module ([#3510](https://github.com/getsentry/sentry-java/pull/3510))
-
-### Fixes
-
 - Support spans that are split into multiple batches ([#3539](https://github.com/getsentry/sentry-java/pull/3539))
     - When spans belonging to a single transaction were split into multiple batches for SpanExporter, we did not add all spans because the isSpanTooOld check wasn't inverted.
-- Parse and use `send-default-pii` and `max-request-body-size` from `sentry.properties` ([#3534](https://github.com/getsentry/sentry-java/pull/3534))
-- `span.startChild` now uses `.makeCurrent()` by default ([#3544](https://github.com/getsentry/sentry-java/pull/3544))
-    - This caused an issue where the span tree wasn't correct because some spans were not added to their direct parent
 - Partially fix bootstrap class loading ([#3543](https://github.com/getsentry/sentry-java/pull/3543))
     - There was a problem with two separate Sentry `Scopes` being active inside each OpenTelemetry `Context` due to using context keys from more than one class loader.
-
-## 8.0.0-alpha.2
-
-### Behavioural Changes
-
-- (Android) The JNI layer for sentry-native has now been moved from sentry-java to sentry-native ([#3189](https://github.com/getsentry/sentry-java/pull/3189))
-    - This now includes prefab support for sentry-native, allowing you to link and access the sentry-native API within your native app code
-    - Checkout the `sentry-samples/sentry-samples-android` example on how to configure CMake and consume `sentry.h`
-
-### Features
-
-- Our `sentry-opentelemetry-agent` has been completely reworked and now plays nicely with the rest of the Java SDK
-    - You may also want to give this new agent a try even if you haven't used OpenTelemetry (with Sentry) before. It offers support for [many more libraries and frameworks](https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/main/docs/supported-libraries.md), improving on our trace propagation, `Scopes` (used to be `Hub`) propagation as well as performance instrumentation (i.e. more spans).
-    - If you are using a framework we did not support before and currently resort to manual instrumentation, please give the agent a try. See [here for a list of supported libraries, frameworks and application servers](https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/main/docs/supported-libraries.md).
-    - NOTE: Not all features have been implemented yet for the OpenTelemetry agent. Features of note that are not working yet:
-        - Metrics
-        - Measurements
-        - `forceFinish` on transaction
-        - `scheduleFinish` on transaction
-        - see [#3436](https://github.com/getsentry/sentry-java/issues/3436) for a more up-to-date list of features we have (not) implemented
-    - Please see "Installing `sentry-opentelemetry-agent`" for more details on how to set up the agent.
-    - What's new about the Agent
-        - When the OpenTelemetry Agent is used, Sentry API creates OpenTelemetry spans under the hood, handing back a wrapper object which bridges the gap between traditional Sentry API and OpenTelemetry. We might be replacing some of the Sentry performance API in the future.
-            - This is achieved by configuring the SDK to use `OtelSpanFactory` instead of `DefaultSpanFactory` which is done automatically by the auto init of the Java Agent.
-        - OpenTelemetry spans are now only turned into Sentry spans when they are finished so they can be sent to the Sentry server.
-        - Now registers an OpenTelemetry `Sampler` which uses Sentry sampling configuration
-        - Other Performance integrations automatically stop creating spans to avoid duplicate spans
-        - The Sentry SDK now makes use of OpenTelemetry `Context` for storing Sentry `Scopes` (which is similar to what used to be called `Hub`) and thus relies on OpenTelemetry for `Context` propagation.
-        - Classes used for the previous version of our OpenTelemetry support have been deprecated but can still be used manually. We're not planning to keep the old agent around in favor of less complexity in the SDK.
-- Add `ignoredSpanOrigins` option for ignoring spans coming from certain integrations
-    - We pre-configure this to ignore Performance instrumentation for Spring and other integrations when using our OpenTelemetry Agent to avoid duplicate spans
-- Add data fetching environment hint to breadcrumb for GraphQL (#3413) ([#3431](https://github.com/getsentry/sentry-java/pull/3431))
-
-### Fixes
-
-- `TracesSampler` is now only created once in `SentryOptions` instead of creating a new one for every `Hub` (which is now `Scopes`). This means we're now creating fewer `SecureRandom` instances.
-- Move onFinishCallback before span or transaction is finished ([#3459](https://github.com/getsentry/sentry-java/pull/3459))
-- Add timestamp when a profile starts ([#3442](https://github.com/getsentry/sentry-java/pull/3442))
-- Move fragment auto span finish to onFragmentStarted ([#3424](https://github.com/getsentry/sentry-java/pull/3424))
-- Remove profiling timeout logic and disable profiling on API 21 ([#3478](https://github.com/getsentry/sentry-java/pull/3478))
-- Properly reset metric flush flag on metric emission ([#3493](https://github.com/getsentry/sentry-java/pull/3493))
-
-### Migration Guide / Deprecations
-
-- Classes used for the previous version of the Sentry OpenTelemetry Java Agent have been deprecated (`SentrySpanProcessor`, `SentryPropagator`, `OpenTelemetryLinkErrorEventProcessor`)
-- Sentry OpenTelemetry Java Agent has been reworked and now allows you to manually create spans using Sentry API as well.
-- Please see "Installing `sentry-opentelemetry-agent`" for more details on how to set up the agent.
-
-### Installing `sentry-opentelemetry-agent`
-
-#### Upgrading from a previous agent
-If you've been using the previous version of `sentry-opentelemetry-agent`, simply replace the agent JAR with the [latest release](https://central.sonatype.com/artifact/io.sentry/sentry-opentelemetry-agent?smo=true) and start your application. That should be it.
-
-#### New to the agent
-If you've not been using OpenTelemetry before, you can add `sentry-opentelemetry-agent` to your setup by downloading the latest release and using it when starting up your application
-- `SENTRY_PROPERTIES_FILE=sentry.properties java -javaagent:sentry-opentelemetry-agent-x.x.x.jar -jar your-application.jar`
-- Please use `sentry.properties` or environment variables to configure the SDK as the agent is now in charge of initializing the SDK and options coming from things like logging integrations or our Spring Boot integration will not take effect.
-- You may find the [docs page](https://docs.sentry.io/platforms/java/tracing/instrumentation/opentelemetry/#using-sentry-opentelemetry-agent-with-auto-initialization) useful. While we haven't updated it yet to reflect the changes described here, the section about using the agent with auto init should still be valid.
-
-If you want to skip auto initialization of the SDK performed by the agent, please follow the steps above and set the environment variable `SENTRY_AUTO_INIT` to `false` then add the following to your `Sentry.init`:
-
-```
-Sentry.init(options -> {
-  options.setDsn("https://3d2ac63d6e1a4c6e9214443678f119a3@o87286.ingest.us.sentry.io/1801383");
-  OpenTelemetryUtil.applyOpenTelemetryOptions(options);
-  ...
-});
-```
-
-If you're using our Spring (Boot) integration with auto init, use the following:
-```
-@Bean
-Sentry.OptionsConfiguration<SentryOptions> optionsConfiguration() {
-  return (options) -> {
-    OpenTelemetryUtil.applyOpenTelemetryOptions(options);
-  };
-}
-```
+- The Spring Boot 3 WebFlux sample now uses our GraphQL v22 integration ([#3828](https://github.com/getsentry/sentry-java/pull/3828))
+- Do not ignore certain span origins for OpenTelemetry without agent ([#3856](https://github.com/getsentry/sentry-java/pull/3856))
+- `span.startChild` now uses `.makeCurrent()` by default ([#3544](https://github.com/getsentry/sentry-java/pull/3544))
+    - This caused an issue where the span tree wasn't correct because some spans were not added to their direct parent
+- Do not set the exception group marker when there is a suppressed exception ([#4056](https://github.com/getsentry/sentry-java/pull/4056))
+    - Due to how grouping works in Sentry currently sometimes the suppressed exception is treated as the main exception. This change ensures we keep using the main exception and not change how grouping works.
+    - As a consequence the list of exceptions in the group on top of an issue is no longer shown in Sentry UI.
+    - We are planning to improve this in the future but opted for this fix first.
 
 ### Dependencies
 
-- Bump Native SDK from v0.7.0 to v0.7.5 ([#3441](https://github.com/getsentry/sentry-java/pull/3189))
-    - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#075)
-    - [diff](https://github.com/getsentry/sentry-native/compare/0.7.0...0.7.5)
-
-## 8.0.0-alpha.1
-
-Version 8 of the Sentry Android/Java SDK brings a variety of features and fixes. The most notable changes are:
-
-- New `Scope` types have been introduced, see "Behavioural Changes" for more details.
-- Lifecycle tokens have been introduced to manage `Scope` lifecycle, see "Behavioural Changes" for more details.
-- `Hub` has been replaced by `Scopes`
-
-### Behavioural Changes
-
-- We're introducing some new `Scope` types in the SDK, allowing for better control over what data is attached where. Previously there was a stack of scopes that was pushed and popped. Instead we now fork scopes for a given lifecycle and then restore the previous scopes. Since `Hub` is gone, it is also never cloned anymore. Separation of data now happens through the different scope types while making it easier to manipulate exactly what you need without having to attach data at the right time to have it apply where wanted.
-    - Global scope is attached to all events created by the SDK. It can also be modified before `Sentry.init` has been called. It can be manipulated using `Sentry.configureScope(ScopeType.GLOBAL, (scope) -> { ... })`.
-    - Isolation scope can be used e.g. to attach data to all events that come up while handling an incoming request. It can also be used for other isolation purposes. It can be manipulated using `Sentry.configureScope(ScopeType.ISOLATION, (scope) -> { ... })`. The SDK automatically forks isolation scope in certain cases like incoming requests, CRON jobs, Spring `@Async` and more.
-    - Current scope is forked often and data added to it is only added to events that are created while this scope is active. Data is also passed on to newly forked child scopes but not to parents.
-- `Sentry.popScope` has been deprecated, please call `.close()` on the token returned by `Sentry.pushScope` instead or use it in a way described in more detail in "Migration Guide".
-- We have chosen a default scope that is used for `Sentry.configureScope()` as well as API like `Sentry.setTag()`
-    - For Android the type defaults to `CURRENT` scope
-    - For Backend and other JVM applicatons it defaults to `ISOLATION` scope
-- Event processors on `Scope` can now be ordered by overriding the `getOrder` method on implementations of `EventProcessor`. NOTE: This order only applies to event processors on `Scope` but not `SentryOptions` at the moment. Feel free to request this if you need it.
-- `Hub` is deprecated in favor of `Scopes`, alongside some `Hub` relevant APIs. More details can be found in the "Migration Guide" section.
-
-### Breaking Changes
-
-- `Contexts` no longer extends `ConcurrentHashMap`, instead we offer a selected set of methods.
+- Bump Native SDK from v0.7.0 to v0.7.17 ([#3441](https://github.com/getsentry/sentry-java/pull/3189)) ([#3851](https://github.com/getsentry/sentry-java/pull/3851)) ([#3914](https://github.com/getsentry/sentry-java/pull/3914)) ([#4003](https://github.com/getsentry/sentry-java/pull/4003))
+    - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0717)
+    - [diff](https://github.com/getsentry/sentry-native/compare/0.7.0...0.7.17)
+- Bump OpenTelemetry to 1.44.1, OpenTelemetry Java Agent to 2.10.0 and Semantic Conventions to 1.28.0 ([#3668](https://github.com/getsentry/sentry-java/pull/3668)) ([#3935](https://github.com/getsentry/sentry-java/pull/3935))
 
 ### Migration Guide / Deprecations
 
+Please take a look at [our migration guide in docs](https://docs.sentry.io/platforms/java/migration/7.x-to-8.0).
+
 - `Hub` has been deprecated, we're replacing the following:
     - `IHub` has been replaced by `IScopes`, however you should be able to simply pass `IHub` instances to code expecting `IScopes`, allowing for an easier migration.
     - `HubAdapter.getInstance()` has been replaced by `ScopesAdapter.getInstance()`
@@ -421,12 +279,22 @@ try (final @NotNull ISentryLifecycleToken ignored = Sentry.pushIsolationScope())
   // this block has its separate isolation scope
 }
 ```
+- Classes used by our previous OpenTelemetry integration have been deprecated (`SentrySpanProcessor`, `SentryPropagator`, `OpenTelemetryLinkErrorEventProcessor`). Please take a look at [docs](https://docs.sentry.io/platforms/java/tracing/instrumentation/opentelemetry/) on how to setup OpenTelemetry in v8.
 
 You may also use `LifecycleHelper.close(token)`, e.g. in case you need to pass the token around for closing later.
 
-### Features
 
-- Report exceptions returned by Throwable.getSuppressed() to Sentry as exception groups ([#3396] https://github.com/getsentry/sentry-java/pull/3396)
+### Changes from `rc.4`
+
+If you have been using `8.0.0-rc.4` of the Java SDK, here's the new changes that have been included in the `8.0.0` release:
+
+- Make `SentryClient` constructor public ([#4045](https://github.com/getsentry/sentry-java/pull/4045))
+- The user ip-address is now only set to `"{{auto}}"` if sendDefaultPii is enabled ([#4072](https://github.com/getsentry/sentry-java/pull/4072))
+    - This change gives you control over IP address collection directly on the client
+- Do not set the exception group marker when there is a suppressed exception ([#4056](https://github.com/getsentry/sentry-java/pull/4056))
+    - Due to how grouping works in Sentry currently sometimes the suppressed exception is treated as the main exception. This change ensures we keep using the main exception and not change how grouping works.
+    - As a consequence the list of exceptions in the group on top of an issue is no longer shown in Sentry UI.
+    - We are planning to improve this in the future but opted for this fix first.
 
 ## 7.20.0
 

From fc52a26cbaa35cfc7b450f02db9e39756b7c02d7 Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Tue, 21 Jan 2025 09:51:38 +0100
Subject: [PATCH 5/7] Fix swallow NDK loadLibrary errors (#4082)

* Fix swallow NDK loadLibrary errors

* Update Changelog
---
 CHANGELOG.md                                                   | 1 +
 .../src/main/java/io/sentry/android/ndk/SentryNdk.java         | 3 +++
 2 files changed, 4 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 00dbe2f7df..dfdfa2879b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -295,6 +295,7 @@ If you have been using `8.0.0-rc.4` of the Java SDK, here's the new changes that
     - Due to how grouping works in Sentry currently sometimes the suppressed exception is treated as the main exception. This change ensures we keep using the main exception and not change how grouping works.
     - As a consequence the list of exceptions in the group on top of an issue is no longer shown in Sentry UI.
     - We are planning to improve this in the future but opted for this fix first.
+- Fix swallow NDK loadLibrary errors ([#4082](https://github.com/getsentry/sentry-java/pull/4082))
 
 ## 7.20.0
 
diff --git a/sentry-android-ndk/src/main/java/io/sentry/android/ndk/SentryNdk.java b/sentry-android-ndk/src/main/java/io/sentry/android/ndk/SentryNdk.java
index a37475002e..aafd66b059 100644
--- a/sentry-android-ndk/src/main/java/io/sentry/android/ndk/SentryNdk.java
+++ b/sentry-android-ndk/src/main/java/io/sentry/android/ndk/SentryNdk.java
@@ -22,6 +22,9 @@ private SentryNdk() {}
               try {
                 //noinspection UnstableApiUsage
                 io.sentry.ndk.SentryNdk.loadNativeLibraries();
+              } catch (Throwable t) {
+                // ignored
+                // if loadLibrary() fails, the later init() will throw an exception anyway
               } finally {
                 loadLibraryLatch.countDown();
               }

From c0a25707db8ac982ad4e7967e3c29afd1597a0b6 Mon Sep 17 00:00:00 2001
From: getsentry-bot <bot@sentry.io>
Date: Tue, 21 Jan 2025 12:42:05 +0000
Subject: [PATCH 6/7] release: 8.0.0

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index dfdfa2879b..30aba6f133 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.0.0
 
 Version 8 of the Sentry Android/Java SDK brings a variety of features and fixes. The most notable changes are:
 
diff --git a/gradle.properties b/gradle.properties
index 0e16313e4c..8d0a3090f0 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -13,7 +13,7 @@ android.useAndroidX=true
 android.defaults.buildfeatures.buildconfig=true
 
 # Release information
-versionName=8.0.0-rc.4
+versionName=8.0.0
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From 1eb21a00efae667b5d923b3c997092b52df842ff Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Tue, 21 Jan 2025 14:21:29 +0100
Subject: [PATCH 7/7] Add modules that are new in v8 to .craft.yml (#4078)

---
 .craft.yml | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/.craft.yml b/.craft.yml
index 0083100920..0fcfc92360 100644
--- a/.craft.yml
+++ b/.craft.yml
@@ -43,14 +43,15 @@ targets:
       maven:io.sentry:sentry-openfeign:
       maven:io.sentry:sentry-opentelemetry-agent:
       maven:io.sentry:sentry-opentelemetry-agentcustomization:
+      maven:io.sentry:sentry-opentelemetry-agentless:
+      maven:io.sentry:sentry-opentelemetry-agentless-spring:
+      maven:io.sentry:sentry-opentelemetry-bootstrap:
       maven:io.sentry:sentry-opentelemetry-core:
-#      maven:io.sentry:sentry-opentelemetry-agentless:
-#      maven:io.sentry:sentry-opentelemetry-agentless-spring:
       maven:io.sentry:sentry-apollo:
       maven:io.sentry:sentry-jdbc:
       maven:io.sentry:sentry-graphql:
-#      maven:io.sentry:sentry-graphql-core:
-#      maven:io.sentry:sentry-graphql-22:
+      maven:io.sentry:sentry-graphql-22:
+      maven:io.sentry:sentry-graphql-core:
       maven:io.sentry:sentry-quartz:
       maven:io.sentry:sentry-okhttp:
       maven:io.sentry:sentry-android-navigation: