docs: APM Services for Error Handling

With a previous PR Sentry was removed from middleware section, which I believe was the write decision.

https://github.com/fastapi/fastapi/pull/12031

Similar to other frameworks, it makes more sense in an error handling section. Long term it might be interesting to have something observability more generically, and not specific to Sentry. Logs, spans, and metrics. How different tools can help developers gain more insights in their code and debug faster.

docs/de/docs/tutorial/handling-errors.md

@@ -19,6 +19,58 @@ Die Statuscodes im 400er-Bereich bedeuten hingegen, dass es einen Fehler gab.
 
 Erinnern Sie sich an all diese **404 Not Found** Fehler (und Witze)?
 
+## Fehlerüberwachungstools
+
+<a href="https://sentry.io/welcome" class="external-link" target="_blank">Sentry</a> ist ein Anwendungsüberwachungsdienst, der Entwicklern hilft, Probleme in Echtzeit zu identifizieren und zu beheben. Sentry bietet:
+
+* Fehlergruppierung zur Aggregation ähnlicher Fehler
+* Quellcode-Kontext aus Stack-Traces
+* Detaillierte Anfrageinformationen
+* Leistungsüberwachung für Webanfragen, Datenbankabfragen und mehr
+* Verteiltes Tracing, um zu verstehen, wie sich Fehler über den Stack ausbreiten
+
+Um Sentry mit FastAPI zu verwenden, installieren Sie zuerst das SDK:
+
+```bash
+pip install --upgrade 'sentry-sdk[fastapi]'
+```
+
+Initialisieren Sie dann Sentry in Ihrer Anwendung:
+
+```python
+import sentry_sdk
+from fastapi import FastAPI
+
+sentry_sdk.init(
+    dsn="your-dsn-here",
+    # Setzen Sie traces_sample_rate, um den Prozentsatz der an Sentry zu sendenden Traces zu konfigurieren, wobei 1.0 100% entspricht
+    traces_sample_rate=1.0,
+)
+
+app = FastAPI()
+
+# Ihr FastAPI-Code hier
+```
+
+Sentry erfasst automatisch unbehandelte Ausnahmen, aber Sie können auch explizit Ausnahmen erfassen und benutzerdefinierte Events senden:
+
+```python
+@app.get("/items/{item_id}")
+async def read_item(item_id: int):
+    try:
+        # Ihr Code, der fehlschlagen könnte
+        if item_id == 0:
+            raise ValueError("Item ID kann nicht Null sein")
+        # ...
+    except Exception as e:
+        # Erfassen Sie die Ausnahme
+        sentry_sdk.capture_exception(e)
+        # Sie können die Ausnahme weiterhin normal behandeln
+        raise HTTPException(status_code=500, detail="Interner Serverfehler")
+```
+
+Weitere Informationen finden Sie in der <a href="https://docs.sentry.io/platforms/python/guides/fastapi/" class="external-link" target="_blank">Sentry FastAPI-Integrationsdokumentation</a>.
+
 ## `HTTPException` verwenden
 
 Um HTTP-Responses mit Fehlern zum Client zurückzugeben, verwenden Sie `HTTPException`.
@@ -51,7 +103,7 @@ Wenn der Client `http://example.com/items/foo` anfragt (ein `item_id` `"foo"`),
 }
 ```
 
-Aber wenn der Client `http://example.com/items/bar` anfragt (ein nicht-existierendes `item_id` `"bar"`), erhält er einen HTTP-Statuscode 404 (der „Not Found“-Fehler), und eine JSON-Response wie folgt:
+Aber wenn der Client `http://example.com/items/bar` anfragt (ein nicht-existierendes `item_id` `"bar"`), erhält er einen HTTP-Statuscode 404 (der "Not Found"-Fehler), und eine JSON-Response wie folgt:
 
 ```JSON
 {
@@ -166,7 +218,7 @@ Das folgende sind technische Details, die Sie überspringen können, wenn sie f
 
 **FastAPI** verwendet diesen, sodass Sie, wenn Sie ein Pydantic-Modell für `response_model` verwenden, und ihre Daten fehlerhaft sind, einen Fehler in ihrem Log sehen.
 
-Aber der Client/Benutzer sieht ihn nicht. Stattdessen erhält der Client einen <abbr title="Interner Server-Fehler">„Internal Server Error“</abbr> mit einem HTTP-Statuscode `500`.
+Aber der Client/Benutzer sieht ihn nicht. Stattdessen erhält der Client einen <abbr title="Interner Server-Fehler">""Internal Server Error""</abbr> mit einem HTTP-Statuscode `500`.
 
 Das ist, wie es sein sollte, denn wenn Sie einen Pydantic-`ValidationError` in Ihrer *Response* oder irgendwo sonst in ihrem Code haben (es sei denn, im *Request* des Clients), ist das tatsächlich ein Bug in ihrem Code.
 
@@ -230,7 +282,7 @@ Sie erhalten eine Response, die Ihnen sagt, dass die Daten ungültig sind, und w
 
 **FastAPI** hat seine eigene `HTTPException`.
 
-Und **FastAPI**s `HTTPException`-Fehlerklasse erbt von Starlettes `HTTPException`-Fehlerklasse.
+Und **FastAPIs** `HTTPException`-Fehlerklasse erbt von Starlettes `HTTPException`-Fehlerklasse.
 
 Der einzige Unterschied besteht darin, dass **FastAPIs** `HTTPException` alles für das Feld `detail` akzeptiert, was nach JSON konvertiert werden kann, während Starlettes `HTTPException` nur Strings zulässt.
 

docs/en/docs/tutorial/handling-errors.md

@@ -19,6 +19,58 @@ The status codes in the 400 range mean that there was an error from the client.
 
 Remember all those **"404 Not Found"** errors (and jokes)?
 
+## Error Monitoring Tools
+
+<a href="https://sentry.io/welcome" class="external-link" target="_blank">Sentry</a> is an application monitoring service that helps developers identify and fix issues in real-time. Sentry provides:
+
+* Error grouping to aggregate similar errors
+* Source code context from stack traces
+* Detailed request information
+* Performance monitoring for web requests, database queries, and more
+* Distributed tracing to understand how errors propagate across your stack
+
+To use Sentry with FastAPI, first install the SDK:
+
+```bash
+pip install --upgrade 'sentry-sdk[fastapi]'
+```
+
+Then initialize Sentry in your application:
+
+```python
+import sentry_sdk
+from fastapi import FastAPI
+
+sentry_sdk.init(
+    dsn="your-dsn-here",
+    # Set traces_sample_rate to configure the percent of traces to send to Sentry, where 1.0 is 100%
+    traces_sample_rate=1.0,
+)
+
+app = FastAPI()
+
+# Your FastAPI code here
+```
+
+Sentry will automatically capture unhandled exceptions, but you can also explicitly capture exceptions and send custom events:
+
+```python
+@app.get("/items/{item_id}")
+async def read_item(item_id: int):
+    try:
+        # Your code that might fail
+        if item_id == 0:
+            raise ValueError("Item ID cannot be zero")
+        # ...
+    except Exception as e:
+        # Capture the exception
+        sentry_sdk.capture_exception(e)
+        # You can still handle the exception normally
+        raise HTTPException(status_code=500, detail="Internal server error")
+```
+
+For more information, see the <a href="https://docs.sentry.io/platforms/python/guides/fastapi/" class="external-link" target="_blank">Sentry FastAPI integration documentation</a>.
+
 ## Use `HTTPException`
 
 To return HTTP responses with errors to the client you use `HTTPException`.

docs/es/docs/tutorial/handling-errors.md

@@ -19,6 +19,58 @@ Los códigos de estado en el rango de 400 significan que hubo un error por parte
 
 ¿Recuerdas todos esos errores de **"404 Not Found"** (y chistes)?
 
+## Herramientas de Monitoreo de Errores
+
+<a href="https://sentry.io/welcome" class="external-link" target="_blank">Sentry</a> es un servicio de monitoreo de aplicaciones que ayuda a los desarrolladores a identificar y solucionar problemas en tiempo real. Sentry proporciona:
+
+* Agrupación de errores para agregar errores similares
+* Contexto del código fuente de los rastros de pila
+* Información detallada de las solicitudes
+* Monitoreo de rendimiento para solicitudes web, consultas de bases de datos y más
+* Rastreo distribuido para entender cómo se propagan los errores a través de su stack
+
+Para usar Sentry con FastAPI, primero instale el SDK:
+
+```bash
+pip install --upgrade 'sentry-sdk[fastapi]'
+```
+
+Luego inicialice Sentry en su aplicación:
+
+```python
+import sentry_sdk
+from fastapi import FastAPI
+
+sentry_sdk.init(
+    dsn="your-dsn-here",
+    # Configure traces_sample_rate para establecer el porcentaje de trazas a enviar a Sentry, donde 1.0 es 100%
+    traces_sample_rate=1.0,
+)
+
+app = FastAPI()
+
+# Su código FastAPI aquí
+```
+
+Sentry capturará automáticamente las excepciones no manejadas, pero también puede capturar excepciones explícitamente y enviar eventos personalizados:
+
+```python
+@app.get("/items/{item_id}")
+async def read_item(item_id: int):
+    try:
+        # Su código que podría fallar
+        if item_id == 0:
+            raise ValueError("El ID del ítem no puede ser cero")
+        # ...
+    except Exception as e:
+        # Capture la excepción
+        sentry_sdk.capture_exception(e)
+        # Aún puede manejar la excepción normalmente
+        raise HTTPException(status_code=500, detail="Error interno del servidor")
+```
+
+Para más información, consulte la <a href="https://docs.sentry.io/platforms/python/guides/fastapi/" class="external-link" target="_blank">documentación de integración de Sentry para FastAPI</a>.
+
 ## Usa `HTTPException`
 
 Para devolver responses HTTP con errores al cliente, usa `HTTPException`.