Updated backend tutorial (#10875)

Brought the Backend tutorial up to date to the new SDK api.

---------

Co-authored-by: Liza Mock <[email protected]>

Author: antonpirker

docs/product/sentry-basics/integrate-backend/capturing-errors.mdx

@@ -14,13 +14,17 @@ If you're using your own source code, follow the instructions in [Getting Starte
 
 ## Unhandled Errors
 
-The Sentry SDK will automatically capture and report any _unhandled error_ that happens in your application runtime without any additional configuration or explicit handling. Generally, unhandled errors are errors that aren't caught by any except (or try/catch) clause.
+The Sentry SDK will automatically capture and report any _unhandled error_ that occurs in your application runtime without any additional configuration or explicit handling. Generally, unhandled errors are errors that aren't caught by a `try/except` clause.
 
-1. In your browser, launch the local Django app in the following endpoint to trigger an unhandled error: `http://localhost:8000/unhandled`.
+To trigger an unhandled error:
 
-2. If you've set up an alert rule, you should be notified about the error. Otherwise, open the **Issues** page in your Sentry account.
+1. Run the local Django app.
 
-3. Notice the unhandled exception appears in the list of issues.
+2. Point your browser to `http://localhost:8000/unhandled`.
+
+2. If you've set up an [alert rule](/product/alerts/create-alerts/), you should be notified about the error. Otherwise, open the [**Issues**](https://sentry.io/orgredirect/organizations/:orgslug/issues/) page in your Sentry account.
+
+3. You should see the unhandled exception in the list of issues.
 
    ![Unhandled Issue](./img/unhandled_issue.png)
 
@@ -30,9 +34,9 @@ The Sentry SDK will automatically capture and report any _unhandled error_ that
 
 5. Notice that the event:
 
-   - Is tagged with the `environment` and `release` options we've set in the previous tutorial and `handled:no`, marking this event as an unhandled error
-   - Contains a suspect commit, made possible because of the commit tracking feature we enabled previously
-   - Contains the custom breadcrumb we added through the SDK
+   - Is tagged with the `environment` and `release` options we've set in the previous tutorial with the tag `handled:no`, marking this event as an unhandled error.
+   - Contains a suspect commit, made possible because of the commit-tracking feature we enabled earlier.
+   - Contains the custom breadcrumb we added through the SDK.
 
      ![Unhandled Breadcrumbs](./img/unhandled_issue_breadcrumbs.png)
 
@@ -44,13 +48,23 @@ The Sentry SDK contains several methods that you can use to **explicitly** repor
 
 1. Open the `views.py` file. Notice that we import `sentry_sdk` lib which contains the `capture_exception` method:
 
-   ```python
-      import sentry_sdk
+   ```python {filename: myapp/views.py}
+   import sentry_sdk
    ```
 
 2. The method is used to capture the exception handled by the except clause in `HandledErrorView`:
 
-   ![Import and Configure SDK](./img/capture_exception.png)
+   ```python {filename: myapp/views.py}
+   class HandledErrorView(APIView):
+      def get(self, request):
+         ...
+         try:
+             '2' + 2
+         except Exception as err:
+             sentry_sdk.capture_exception(err)
+
+         return Response()
+   ```
 
 3. To try it out on your localhost, trigger the following endpoint: `http://localhost:8000/handled`.
 
@@ -70,22 +84,26 @@ Typically, `capture_message` is not emitted, but there are times when a develope
 
 2. You can use it anywhere within your app. In our example, we've created a dedicated view class, `CaptureMessageView`, to trigger and capture a message we want to track:
 
-   ```Python
-      sentry_sdk.capture_message("You caught me!")
+   ```python {filename: myapp/views.py}
+   sentry_sdk.capture_message("You caught me!")
    ```
 
 3. To try it out on your localhost, trigger the following endpoint: `http://localhost:8000/message`.
 
 4. As before, open the new issue’s detail page from the **Issues** page.
+   <Alert>
+      You'll need to remove the `"issue.priority is high or medium"` filter from the "Custom Search" field on the [**Issues**](https://sentry.io/orgredirect/organizations/:orgslug/issues/) page to see all the issue types in the list.
+   </Alert>
+
 
    ![Import and Configure SDK](./img/capture_message.png)
 
-   > By default captured messages are marked with a severity level tag `level:info`, as reflected in the tags section. However, the `capture_message` methods accept an **optional** severity level parameter.
+   > By default, captured messages are marked with a severity level tag `level:info`, as reflected in the tags section. However, the `capture_message` methods accept an **optional** severity level parameter.
 
 5. In the `views.py` file, change the `capture_message` method to:
 
-   ```Python
-      sentry_sdk.capture_message("You caught me!", "fatal")
+   ```python {filename: myapp/views.py}
+   sentry_sdk.capture_message("You caught me!", "fatal")
    ```
 
 6. Save the changes and trigger the `/message` endpoint again. Changes should be applied immediately through `StateReloader`.
@@ -94,28 +112,27 @@ Typically, `capture_message` is not emitted, but there are times when a develope
 
 ## Enriching your Event Data
 
-You can enrich your event and error data through the Sentry SDK by adding custom tags and user context attributes. In addition to providing more context to your errors, those will expand your options to search, filter, and query through your event metadata. Learn more about the advantages of enriching your data in [Event Data](/product/sentry-basics/enrich-data/).
+You can enrich your event and error data through the Sentry SDK by adding custom tags and user context attributes. In addition to providing more context to your errors, enriched data will expand your options to search, filter, and query through your event metadata. Learn more about the advantages of enriching your data in [Event Data](/product/sentry-basics/enrich-data/).
 
 To enrich the data of the message events we've captured with `capture_message`:
 
 1. In the `views.py` file, locate the line that triggers `sentry_sdk.capture_message`.
 
 2. Replace that line with the following code:
 
-   ```Python
-   with sentry_sdk.push_scope() as scope:
-      scope.set_tag("my-tag", "my value")
-      scope.user = { "email" : "[email protected]" }
-      scope.set_extra("someVariable", "some data")
+   ```python {filename: myapp/views.py}
+   sentry_sdk.set_tag("my-tag", "my value")
+   sentry_sdk.user = { "email" : "[email protected]" }
+   sentry_sdk.set_extra("someVariable", "some data")
 
-      sentry_sdk.capture_message("You caught me!", "fatal")
+   sentry_sdk.capture_message("You caught me!", "fatal")
    ```
 
    > We're using the `push_scope` method that allows us to send data with one specific event on a local scope. We're setting a custom tag, user context attribute (email), and extra data on the local scope to enrich the data on the message event.
 
 3. Save your changes and trigger the `/message` endpoint again.
 
-4. Open the issue’s detail page from the **Issues** page.
+4. Open the issue’s detail page from the [**Issues**](https://sentry.io/orgredirect/organizations/:orgslug/issues/) page.
 
 5. Notice that:
 

docs/product/sentry-basics/integrate-backend/configuration-options.mdx

@@ -4,84 +4,92 @@ sidebar_order: 2
 description: "Learn how to configure releases, breadcrumbs, and environments to enhance the SDK's functionality."
 ---
 
-Sentry has various configuration options to help enhance the SDK functionality. The options can help provide additional data needed to debug issues even faster or help control what is sent to Sentry by filtering. Learn more in [Configuration](/platforms/python/configuration/).
+Sentry has various configuration options to help enhance the SDK functionality. The options can help provide additional data needed to debug issues even faster or to help control what's sent to Sentry by filtering. Learn more in [Configuration](/platforms/python/configuration/).
 
 ## Releases
 
-A _release_ is a version of your code that is deployed to an environment. Configuring the release helps you figure out if there is a regression in your code, create accountability, resolve issues within Sentry, and stay up to date with your deployments. Releases need to be configured within your SDK and then managed through the [sentry-cli](/product/cli/).
+A _release_ is a version of your code that's deployed to an environment. Configuring the release helps you figure out if there's a regression in your code, ensure accountability, resolve issues within Sentry, and stay up-to-date with your deployments. Releases need to be configured within your SDK and then managed through the [sentry-cli](/product/cli/).
 
 Sentry currently supports integrations with GitHub, Bitbucket, Azure DevOps, GitLab, and others. For a complete list of our integrations, check out our [Integrations documentation](/organization/integrations/).
 
 To set up the release in this project:
 
 1. Open the file `settings.py`. Notice that we add the `release` configuration option when initializing the SDK:
 
-   ```python
-   release=os.environ.get("VERSION"),
+   ```python {filename: myproject/settings.py}
+   sentry_sdk.init(
+       ...
+       release=os.environ.get("VERSION"),
+       ...
+   )
    ```
 
 2. Open the `Makefile` you ran in the previous tutorial.
 
    ![Makefile](./img/makefile.png)
 
-3. Notice that we're setting the release version name as an environment variable that is then used in the application's runtime. We're letting the CLI propose a release version name, but you'd probably want to apply your naming conventions:
+3. Notice that we're setting the release version name as an environment variable that's then used in the application's runtime. We're letting the CLI propose a release version name, but you probably want to apply your own naming conventions:
 
-   ```bash
+   ```Makefile {filename: Makefile}
    VERSION=`sentry-cli releases propose-version`
    ```
 
-4. Then we create the new release for our project with the proposed or selected name.
+4. We then create a new release for our project with the proposed or selected name.
 
-   ```bash
-   > create_release:
-      sentry-cli releases -o $(SENTRY_ORG) new -p $(SENTRY_PROJECT) $(VERSION)
+   ```Makefile {filename: Makefile}
+   create_release:
+       sentry-cli releases -o $(SENTRY_ORG) new -p $(SENTRY_PROJECT) $(VERSION)
    ```
 
 5. In the previous tutorial, we configured the GitHub integration and added the code repository for commit tracking. Now we can associate commits from that repository to the new release by running the command:
 
-   ```bash
-   > associate_commits:
-         sentry-cli releases -o $(SENTRY_ORG) -p $(SENTRY_PROJECT) \
-         set-commits $(VERSION) --auto
+   ```Makefile {filename: Makefile}
+   associate_commits:
+       sentry-cli releases -o $(SENTRY_ORG) -p $(SENTRY_PROJECT) \
+           set-commits $(VERSION) --auto
    ```
 
 ## Breadcrumbs
 
-_Breadcrumbs_ are the trail of events that led up to the error. They can be quite useful when trying to reproduce an issue. Depending on the platform, the SDK will track various types of breadcrumbs by default (for backend SDKs those are DB queries, network events, logging, and others), and you can add custom breadcrumbs as well.
+_Breadcrumbs_ are the trail of events that led up to an error. They're very useful for reproducing an issue. Depending on the platform, the SDK will track various types of breadcrumbs by default (for backend SDKs these are DB queries, network events, logging, and others). You can also add your own custom breadcrumbs.
 
 To add breadcrumbs to our app:
 
 1. Open the file `myapp > view.py`.
 
-2. Notice we import `add_breadcrumb` from the SDK lib.
+2. Notice that we import the `sentry_sdk` lib, which contains the `add_breadcrumb` method:
 
-   ```python
-   from sentry_sdk import add_breadcrumb
+   ```python {filename: myapp/views.py}
+   import sentry_sdk
    ```
 
-3. We create a custom breadcrumb for each method handler in the view classes. This breadcrumb will be added to the trail of breadcrumbs associated with any error triggered through these method call flows. For instance, under `HandledErrorView:get`:
+3. We then create a custom breadcrumb for each method-handler in the view classes. This breadcrumb gets added to the trail of breadcrumbs associated with any error triggered through these method call flows. For instance, under `HandledErrorView.get`:
 
-   ```python
-    add_breadcrumb(
-      category='URL Endpoints',
-      message='In the handled function',
-      level='info',
+   ```python {filename: myapp/views.py}
+   sentry_sdk.add_breadcrumb(
+       category='URL Endpoints',
+       message='In the handled function',
+       level='info',
    )
    ```
 
 ## Environment
 
-_Environment_ is a powerful configuration option that enables developers using Sentry to perform various workflows, such as filtering issues and triggering alerts, in the context of the deployment environment in which the errors occurred.
+_Environment_ is a powerful configuration option that enables developers using Sentry to perform various workflows, (such as filtering issues and triggering alerts) in the context of the deployment environment in which the errors occurred.
 
 1. Open the `settings.py` file.
 
 2. Notice that we initialize the SDK with the `environment` configuration option. Any event that's subsequently captured by the SDK will be tagged with the configured environment value.
 
-   ```python
-    environment:"Production"
+   ```python {filename: myproject/settings.py}
+   sentry_sdk.init(
+       ...
+       environment="Production"
+       ...
+   )
    ```
 
-   > Environment values are freeform strings. Neither the Sentry SDK nor [sentry.io](https://sentry.io) will not limit you to any specific value or format. In this example, we hardcoded the value. In a real-life app, the value would probably be determined dynamically through a properties file, system, or environment variable.
+   > Environment values are freeform strings. Neither the Sentry SDK nor [sentry.io](https://sentry.io) will limit you to any specific value or format. In this example, we hardcoded the value. In a real-life app, the value would probably be determined dynamically through a properties file, system, or environment variable.
 
 ## Next