flutter v9: update snippets (#13496)

Closes getsentry/sentry-dart#2702

Do not merge until Flutter v9 is GA

---------

Co-authored-by: Alex Krawiec <alex.krawiec@sentry.io>
Co-authored-by: Giancarlo Buenaflor <giancarlobuenaflor@JL7VJ73Q6N.local>

Author: 3 people

docs/platforms/dart/common/metrics/index.mdx

@@ -361,12 +361,6 @@ Set this boolean to `true` to enable reporting [FlutterErrorDetails.silent](http
 
 </ConfigKey>
 
-<ConfigKey name="autoAppStart">
-
-Set this boolean to `false` to disable automatic app start tracking.
-
-</ConfigKey>
-
 <ConfigKey name="enableAutoNativeBreadcrumbs">
 
 Set this boolean to `false` to disable automatic breadcrumbs on the Native platforms.

docs/platforms/dart/guides/flutter/configuration/options.mdx

@@ -64,12 +64,6 @@ Monitor the [health of releases](/product/releases/health/) by observing user ad
 
 In order to monitor release health, the SDK sends session data.
 
-<Alert>
-
-Release health in Flutter is only available for Android, iOS, and macOS.
-
-</Alert>
-
 ### Sessions
 
 A session represents the interaction between the user and the application. Sessions contain a timestamp, a status (if the session was OK or if it crashed), and are always linked to a release. Most Sentry SDKs can manage sessions automatically.

docs/platforms/dart/guides/flutter/configuration/releases.mdx

@@ -19,14 +19,15 @@ options.beforeSend = (event, hint) async {
           baseUrl,
           '${baseUrl}my_prefix/',
         );
-        return frame.copyWith(absPath: modifiedAbsPath);
+        frame.absPath = modifiedAbsPath;
+        return frame;
       }).toList();
-      return exception.copyWith(
-        stackTrace: SentryStackTrace(frames: frames),
-      );
+      exception.stackTrace = SentryStackTrace(frames: frames);
+      return exception;
     }
     return exception;
   }).toList();
-  return event.copyWith(exceptions: exceptions ?? []);
+  event.exceptions = exceptions ?? [];
+  return event;
 };
 ```

docs/platforms/dart/guides/flutter/configuration/rewriteframes.mdx

@@ -3,8 +3,6 @@ title: "View Hierarchy"
 description: "Learn more about debugging the view hierarchy when an error occurs. Sentry pairs the view hierarchy representation with the original event, giving you additional insight into issues."
 ---
 
-<Include name="feature-stage-beta.mdx" />
-
 Sentry makes it possible to render a JSON representation of the view hierarchy of an error and includes it as an <PlatformLink to="/enriching-events/attachments/">attachment</PlatformLink>.
 
 This feature only applies to SDKs with a user interface, such as the ones for mobile and desktop applications. In some environments like native iOS, rendering the view hierarchy requires the UI thread and in the event of a crash, that might not be available. Another example where the view hierarchy might not be available is when the event happens before the screen starts to load. So inherently, this feature is a best effort solution.
@@ -23,24 +21,34 @@ View hierarchy debugging is an opt-in feature. You can enable it as shown below:
 
 ### Customize View Hierarchy Capturing
 
-<Alert>
+By default, Flutter limits view hierarchy captures to once every 2 seconds to minimize performance impact. While this debounce interval cannot be changed, you can customize capture behavior by implementing the `beforeCaptureViewHierarchy` callback in your `SentryFlutterOptions`.
 
-Requires SDK version `8.13.0` or higher.
+This callback gives you fine-grained control over view hierarchy captures based on event and hint data, allowing you to implement conditional logic.
 
-</Alert>
+<Alert>
 
-Capturing view hierarchies on Flutter is limited to once every 2 seconds by default to minimize performance impact. While this debounce interval is fixed, you can override individual capture decisions by implementing the `beforeCaptureViewHierarchy` option in your `SentryFlutterOptions`.
+The `shouldDebounce` parameter is `true` if the debounce is active.
+If you want to capture view hierarchies regardless of the debounce, you can ignore the `shouldDebounce` parameter.
 
-The `beforeCaptureViewHierarchy` option allows you to customize behavior based on event data so you can decide when to capture view hierarchy and when not to. For example, you can decide to only capture view hierarchy for fatal events:
+</Alert>
 
-```flutter {2-9}
+```dart {tabTitle: Respect debounce} {2-9}
 await SentryFlutter.init((options) {
-  options.beforeCaptureViewHierarchy = (event, hint, debounce) async {
+  options.beforeCaptureViewHierarchy = (event, hint, shouldDebounce) async {
     // If debounce is active, skip capturing
-    if (debounce) {
+    if (shouldDebounce) {
       return false;
     }
-    // Capture if it's a fatal event
+    // Capture view hierarchy if it's a fatal event
+    return event.level == SentryLevel.fatal;
+  };
+});
+```
+
+```dart {tabTitle: Ignore debounce} {2-4}
+await SentryFlutter.init((options) {
+  options.beforeCaptureViewHierarchy = (event, hint, shouldDebounce) async {
+    // Capture view hierarchy if it's a fatal event regardless of debounce
     return event.level == SentryLevel.fatal;
   };
 });

docs/platforms/dart/guides/flutter/enriching-events/viewhierarchy/index.mdx

@@ -9,7 +9,7 @@ Sentry's Flutter SDK enables automatic reporting of errors and exceptions, and i
 **Features:**
 
 - Under the hood the SDK relies on <Link to="/platforms/dart">Sentry's Dart SDK</Link>:
-    - The minimum required version is `2.17.0` and Flutter SDK version is `3.0.0`.
+    - You need at least Dart `3.5.0` and Flutter `3.24.0`.
     - This SDK includes all the <Link to="/platforms/dart/features">Features of Sentry's Dart SDK</Link>.
 - Automatic native crash error tracking (using both <Link to="/platforms/android">Android</Link> and <Link to="/platforms/apple/guides/ios">iOS</Link>), including:
     - Java, Kotlin, C, and C++ code for Android.
@@ -46,16 +46,13 @@ Sentry supports Flutter Web as well, with the following limitations:
 - Stack traces aren't symbolicated when compiled using WebAssembly (WASM).
 - Stack traces are not symbolicated when loaded as a browser extension.
 - Offline caching isn't supported for exceptions.
-- <Link to="/product/releases/health">Release Health</Link> isn't supported.
-- Device context data isn't as rich on the web as it is on mobile.
 
 **Desktop Limitations:**
 
 Sentry supports Flutter on Linux and Windows as well, with the following limitations:
 
 - Native crashes are not supported on Windows.
 - [Release Health](/product/releases/health/) isn't supported.
-- Device context data isn't as rich on Linux and Windows as it is on mobile.
 
 When running on macOS, you can expect the same feature set as on iOS.
 

docs/platforms/dart/guides/flutter/features/index.mdx

@@ -8,21 +8,24 @@ By default, the Flutter SDK initializes the native SDK underneath the `init` met
 
 To do this, set [autoInitializeNativeSdk](/platforms/dart/guides/flutter/configuration/options/#autoInitializeNativeSdk) to `false` in the init options:
 
-
-```dart
-import 'package:flutter/widgets.dart';
-import 'package:sentry_flutter/sentry_flutter.dart';
-
-Future<void> main() async {
-  await SentryFlutter.init(
-    (options) => options
-      ..dsn = '___PUBLIC_DSN___'
-      ..autoInitializeNativeSdk = false,
-    appRunner: () => runApp(MyApp()),
-  );
-}
+```dart {2}
+await SentryFlutter.init((options) {
+  options.autoInitializeNativeSdk = false;
+}, appRunner: () => runApp(SentryWidget(child: const MyApp())));
 ```
 
 This will prevent the Flutter SDK from initializing the native SDKs automatically.
 
-Next, initialize the [Android](/platforms/android/configuration/manual-init/#manual-initialization) and [iOS (using the configuration guide to initialize the Sentry Cocoa SDK)](/platforms/apple/guides/ios/#configure) native SDKs. Note that you do not need to install the native SDKs as they are already packaged with the Flutter SDK.
+Next, initialize the native SDKs as specified in the guides below.
+
+- [Android](/platforms/android/configuration/manual-init/#manual-initialization)
+- [iOS](/platforms/apple/guides/ios/manual-setup/)
+- [Browser](/platforms/javascript/#configure)
+
+<Alert>
+
+For Web you will need to install the JavaScript SDK by injecting the loader script manually into your HTML's `<head>` tag.
+
+The Android and iOS SDKs are already packaged with the Flutter SDK. 
+
+</Alert>