Merge branch 'master' of https://github.com/getsentry/sentry-docs

* 'master' of https://github.com/getsentry/sentry-docs:
  docs(dev-infra): Update development environment docs (#14585)
  add Sevvy integration docs (#14601)
  feat(dart/flutter): improve distinction between Logging integration and Structured Logs (#14527)
  correcting region storage for symbol and source map metadata (#14600)

Author: codyde

develop-docs/development-infrastructure/environment/index.mdx

@@ -34,12 +34,9 @@ devservices up
 After that, you can start the development server inside the `sentry` folder:
 
 ```shell
-sentry devserver --workers
+devservices serve
 ```
 
-If you are developing for aesthetics only and do not rely on the async workers, you can omit the `--workers` flag in order
-to use fewer system resources.
-
 Access it at [http://dev.getsentry.net:8000](http://dev.getsentry.net:8000) (you'll have to wait a bit for webpack to finish).
 A superuser account should have been created for you during bootstrap - `[email protected]` with password `admin`.
 You can create other users with `sentry createuser`.
@@ -86,8 +83,8 @@ After the server is running we can visit the dev server using `https` at port `:
 <Link to="/relay/">Relay</Link> and the ingest workers are not started by default. Follow the instructions below to start them so you can send events to your dev environment Sentry instance:
 
 - Set `SENTRY_USE_RELAY = True` in `~/.sentry/sentry.conf.py`.
-- Run `devservices up` to start the services Relay needs. (like for example Kafka)
-- (Re-)Start your devserver with the `--ingest` flag (e.g. `sentry devserver --workers --ingest`). This will start the Relay container and all related services alongside your devserver.
+- Run `devservices up --mode ingest` to start the services Relay needs. (like for example Kafka)
+- Start your devserver (e.g. `devservices serve`).
 
 ## Running the Getsentry Development Server
 
@@ -108,7 +105,7 @@ devservices up
 After that, you can start the development server inside the `getsentry` folder:
 
 ```shell
-getsentry devserver --workers
+devservices serve
 ```
 
 **Note**: You **cannot** have both sentry and getsentry devserver running at the same time.
@@ -123,7 +120,7 @@ by `dev.py` if it exists.
 To enable the ingest workers, follow the steps described <Link to="#ingestion-pipeline-relay">here</Link> and run
 
 ```shell
-getsentry devserver --workers --ingest
+devservices serve
 ```
 
 ## Running siloed instances
@@ -134,10 +131,10 @@ The devserver command supports `--silo` option that lets you create siloed insta
 
 ```shell
 # Start control silo servers
-sentry devserver --silo=control --celery-beat --workers
+devservices serve --silo=control --celery-beat
 
 # Start region silo servers
-sentry devserver --silo=region --celery-beat --workers --ingest
+devservices serve --silo=region --celery-beat
 ```
 
 Siloed servers have the following port assignments:

docs/organization/integrations/debugging/index.mdx

@@ -8,6 +8,7 @@ description: "Learn more about Sentry's debugging integrations."
 - [Foam](/organization/integrations/debugging/foamai/)
 - [Revise.dev](/organization/integrations/debugging/revisedev/)
 - [Rookout](/organization/integrations/debugging/rookout/)
+- [Sevvy](/organization/integrations/debugging/sevvy/)
 - [Sourcery](/organization/integrations/debugging/sourcery/)
 - [Tembo](/organization/integrations/debugging/tembo/)
 

docs/organization/integrations/debugging/sevvy/index.mdx

@@ -0,0 +1,21 @@
+---
+title: Sevvy
+sidebar_order: 1
+
+description: "Learn about Sentry's Sevvy integration, which helps users debug, fix, and prevent issues, with full-stack context."
+---
+The Sevvy integration connects Sentry with Sevvy, an AI on-call engineer that monitors your production systems, debugs failures, and performs root-cause analysis using rich context from across your stack. When Issues are created or updated in Sentry, the agent enriches the event 
+with data from your logs, metrics, source code, databases, docs, runbooks, PRs, deployments, and past incidents, summarizing the root cause and remediation steps.
+
+This integration is maintained and supported by Sevvy. or more details, questions, or support feel free to contact [email protected].
+## Install and Configure
+
+<Alert>
+
+Sentry owner, manager, or admin permissions are required to install this integration.
+
+</Alert>
+
+1. Navigate to **Settings > Integrations > Sevvy**
+
+2. Follow the full [Sevvy installation instructions](https://docs.sevvyai.com/integrations/sentry).

docs/organization/integrations/index.mdx

@@ -111,6 +111,7 @@ For more details, see the [full Integration Platform documentation](/organizatio
 | [Foam](/organization/integrations/debugging/foamai/) |                |
 | [Revise.dev](/organization/integrations/debugging/revisedev/) |                |
 | [Rookout](/organization/integrations/debugging/rookout/) | X               |
+| [Sevvy](/organization/integrations/debugging/sevvy/) |                |
 | [Sourcery](/organization/integrations/debugging/sourcery/) |                |
 | [Tembo](/organization/integrations/debugging/tembo/) |                |
 

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

@@ -21,6 +21,10 @@ With Sentry Structured Logs, you can send text based log information from your a
 
 <PlatformContent includePath="logs/usage" />
 
+## Integrations
+
+<PlatformContent includePath="logs/integrations" />
+
 ## Options
 
 <PlatformContent includePath="logs/options" />

includes/dart-integrations/logging.mdx

@@ -1,6 +1,6 @@
 ---
 title: Logging Integration
-description: "Learn more about the Sentry Logging integration for the Dart SDK."
+description: "Integrate Sentry with the Dart Logging package to capture events, breadcrumbs, and automatically send structured logs to Sentry."
 caseStyle: canonical
 supportLevel: production
 sidebar_order: 3
@@ -9,9 +9,19 @@ platforms:
   - flutter
 ---
 
-The `sentry_logging` library provides [Logging](https://pub.dev/packages/logging) support for Sentry using the [onRecord property](https://pub.dev/documentation/logging/latest/logging/Logger/onRecord.html). It is able to collect breadcrumbs and capture events. Once this integration is configured, you can use Logging's public API exclusively or in combination to the Sentry's SDK API to capture and enrich events.
+This integration connects Sentry with the popular [Dart logging package](https://pub.dev/packages/logging), providing the following capabilities:
 
-The source can be found [on GitHub](https://github.com/getsentry/sentry-dart/tree/main/logging/).
+- If `enableLogs` is set to `true`, Sentry will send your log messages as [Sentry Structured Logs](/platforms/dart/logs/) (new in `9.5.0`)
+- Captures breadcrumbs from your log calls
+- Converts error-level logs into Sentry error events
+- Works with your existing logging code
+
+<Alert level="info">
+
+This page covers the instrumentation of the **Dart Logging package**.
+This integration also supports creating structured logs. However, if you're looking to set up Sentry structured logs in general, visit our [Structured Logs](/platforms/dart/logs/) documentation. 
+
+</Alert>
 
 ## Install
 
@@ -26,8 +36,7 @@ dependencies:
 
 ## Configure
 
-Configuration should happen as early as possible in your application's lifecycle.
-
+Add the `LoggingIntegration` to your `Sentry.init` call:
 
 ```dart
 import 'package:sentry_logging/sentry_logging.dart';
@@ -38,36 +47,64 @@ Future<void> main() async {
     (options) {
       options.dsn = '___PUBLIC_DSN___';
       options.addIntegration(LoggingIntegration());
+      // If you want to enable sending structured logs, set `enableLogs` to `true`
+      options.enableLogs = true;
     },
     appRunner: initApp, // Init your App.
   );
 }
 ```
 
+### Configuration Options
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `minBreadcrumbLevel` | `Level.INFO` | Minimum level for creating breadcrumbs |
+| `minEventLevel` | `Level.SEVERE` | Minimum level for creating error events |
+| `minSentryLogLevel` | `Level.INFO` | Minimum level for sending structured logs (requires `enableLogs` to be `true`) |
+
+You can customize which log levels trigger different Sentry features:
+
+```dart
+await Sentry.init(
+  (options) {
+    options.dsn = '___PUBLIC_DSN___';
+    options.addIntegration(LoggingIntegration(
+      minBreadcrumbLevel: Level.INFO,    // Breadcrumbs for INFO and above
+      minEventLevel: Level.SEVERE,       // Error events for SEVERE and above  
+      minSentryLogLevel: Level.INFO,     // Structured logs for INFO and above
+    ));
+  },
+  appRunner: initApp,
+);
+```
+
 ## Verify
 
-This snippet captures an intentional error, so you can test that everything is working as soon as you set it up:
+Add the following snippet to your app and execute it to verify that Sentry is capturing your logs:
 
 ```dart
 import 'package:logging/logging.dart';
 
-void main() async {
+void testLogging() {
   final log = Logger('MyAwesomeLogger');
 
-  log.info('a breadcrumb!');
+  // This creates a breadcrumb AND a structured log (Level.INFO >= defaults)
+  log.info('User logged in successfully');
+  
+  // This creates a breadcrumb AND a structured log (Level.WARNING >= defaults)  
+  log.warning('Rate limit approaching');
 
   try {
-    throw StateError();
+    throw StateError('Something went wrong');
   } catch (error, stackTrace) {
-    log.severe('an error!', error, stackTrace);
+    // This creates a breadcrumb, structured log, AND error event (Level.SEVERE >= all defaults)
+    log.severe('Critical error occurred', error, stackTrace);
   }
 }
 ```
 
-<Alert>
-
-Learn more about manually capturing an error or message, in our <PlatformLink to="/usage/">Usage documentation</PlatformLink>.
-
-</Alert>
-
-To view and resolve the recorded message, log into [sentry.io](https://sentry.io) and open your project. Clicking on the error's title will open a page where you can see detailed information and mark it as resolved.
+### What You'll See in Sentry:
+- **Breadcrumbs**: All three log calls will appear as breadcrumbs on the error event
+- **Error Event**: The `severe` log creates a full error event with stack trace
+- **Structured Logs**: (if `enableLogs` is `true`) Navigate to **Logs** in your Sentry project to see all three entries as searchable structured logs

platform-includes/logs/integrations/dart.mdx

@@ -0,0 +1,4 @@
+Available integrations:
+- [Dart Logging package](/platforms/dart/integrations/logging/)
+
+If there's an integration you would like to see, open a [new issue on GitHub](https://github.com/getsentry/sentry-dart/issues/new/choose).

platform-includes/logs/usage/dart.mdx

@@ -2,14 +2,33 @@ Once the feature is enabled on the SDK and the SDK is initialized, you can send
 
 The `logger` namespace exposes six methods that you can use to log messages at different log levels: `trace`, `debug`, `info`, `warning`, `error`, and `fatal`.
 
-You can pass additional attributes directly to the logging functions. These properties will be sent to Sentry, and can be searched from within the Logs UI, and even added to the Logs views as a dedicated column.
+Aside from the primary logging methods, we've provided a format text function, `Sentry.logger.fmt`, that you can use to insert properties into to your log entries.
+
+These properties will be sent to Sentry, and can be searched from within the Logs UI, and even added to the Logs views as a dedicated column.
+
+<Alert level="info">
+  When using the `fmt` function, you must use the `%s` placeholder for each value you want to insert.
+</Alert>
 
 ```dart
-Sentry.logger.info("A simple log message");
-Sentry.logger.warn("This is a warning log with attributes.", attributes: {
-  'attribute1': SentryLogAttribute.string('string'),
-  'attribute2': SentryLogAttribute.int(1),
-  'attribute3': SentryLogAttribute.double(1.0),
-  'attribute4': SentryLogAttribute.bool(true),
+Sentry.logger.fmt.error('Uh oh, something broke, here is the error: %s', [
+  errorMsg
+], attributes: {
+  'additional_info': SentryLogAttribute.string('some info'),
 });
+Sentry.logger.fmt.info("%s added %s to cart.", [user.username, product.name]);
 ```
+
+You can also pass additional attributes directly to the logging functions, avoiding the need to use the `fmt` function.
+
+```dart
+Sentry.logger.error('Uh oh, something broke, here is the error: $errorMsg',
+    attributes: {
+      'error': SentryLogAttribute.string(errorMsg),
+      'some_info': SentryLogAttribute.string('some info'),
+    });
+Sentry.logger.info('User ${user.username} added ${product.name} to cart.', attributes: {
+  'user': SentryLogAttribute.string(user.username),
+  'product': SentryLogAttribute.string(product.name),
+});
+```