From ef7c7af6f05821a3bc42c122f174b331822ec3b5 Mon Sep 17 00:00:00 2001 From: Stephanie Anderson Date: Thu, 15 Jun 2023 11:30:24 +0200 Subject: [PATCH 001/116] initial skeleton for tracing without performance documentation --- src/components/platformSidebar.tsx | 10 ++++++++++ src/platforms/common/distributed-tracing/index.mdx | 10 ++++++++++ .../{connect-services.mdx => distributed-tracing.mdx} | 2 +- src/platforms/common/performance/index.mdx | 2 +- .../{connect-services.mdx => distributed-tracing.mdx} | 2 +- 5 files changed, 23 insertions(+), 3 deletions(-) create mode 100644 src/platforms/common/distributed-tracing/index.mdx rename src/platforms/common/performance/{connect-services.mdx => distributed-tracing.mdx} (98%) rename src/platforms/php/guides/laravel/performance/{connect-services.mdx => distributed-tracing.mdx} (98%) diff --git a/src/components/platformSidebar.tsx b/src/components/platformSidebar.tsx index 1d98486a66356..ced30d34ea752 100644 --- a/src/components/platformSidebar.tsx +++ b/src/components/platformSidebar.tsx @@ -71,6 +71,7 @@ export function SidebarContent({platform, guide, data}: ChildProps): JSX.Element exclude={[ `/${pathRoot}/enriching-events/`, `/${pathRoot}/data-management/`, + `/${pathRoot}/distributed-tracing/`, `/${pathRoot}/performance/`, `/${pathRoot}/session-replay/`, `/${pathRoot}/profiling/`, @@ -78,6 +79,15 @@ export function SidebarContent({platform, guide, data}: ChildProps): JSX.Element `/${pathRoot}/crons/`, ]} /> + - + diff --git a/src/platforms/php/guides/laravel/performance/connect-services.mdx b/src/platforms/php/guides/laravel/performance/distributed-tracing.mdx similarity index 98% rename from src/platforms/php/guides/laravel/performance/connect-services.mdx rename to src/platforms/php/guides/laravel/performance/distributed-tracing.mdx index eb120128ff482..84f57ffa9f8a3 100644 --- a/src/platforms/php/guides/laravel/performance/connect-services.mdx +++ b/src/platforms/php/guides/laravel/performance/distributed-tracing.mdx @@ -1,5 +1,5 @@ --- -title: Connect Services +title: Distributed Tracing sidebar_order: 40 description: "Learn how to connect backend and frontend transactions." --- From eedae7ad8676c64c998e9063deba928651a4f2aa Mon Sep 17 00:00:00 2001 From: Stephanie Anderson Date: Thu, 15 Jun 2023 13:32:38 +0200 Subject: [PATCH 002/116] notes about required content --- .../common/distributed-tracing/index.mdx | 63 +++++++++++++++++++ .../automatic-instrumentation.mdx | 19 ++++++ .../instrumentation/index.mdx | 10 +++ .../manual-instrumentation.mdx | 22 +++++++ 4 files changed, 114 insertions(+) create mode 100644 src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx create mode 100644 src/platforms/common/distributed-tracing/instrumentation/index.mdx create mode 100644 src/platforms/common/distributed-tracing/instrumentation/manual-instrumentation.mdx diff --git a/src/platforms/common/distributed-tracing/index.mdx b/src/platforms/common/distributed-tracing/index.mdx index f8228fe86c8ba..137900b71979b 100644 --- a/src/platforms/common/distributed-tracing/index.mdx +++ b/src/platforms/common/distributed-tracing/index.mdx @@ -8,3 +8,66 @@ supported: - php - python --- + +Was ist dt und warum ist es cool? + +-> vielleicht etwas von der Produktseite übernehmen + +Ab welcher Version ist es supported? + +# Supported frameworks + +- aiohttp +- aws_lambda +- bottle +- celery +- django +- falcon +- fastapi +- flask +- gcp +- pyramid +- quart +- rq +- starlette +- starlite +- tornado +- trytond + + +# Configure + +Es gibt zwei header + +* `sentry-trace` +* `baggage` + +TODO: header beschreiben +beispiel header anzeigen + + +Config fürs limitieren auf gewisse hosts +`trace-propagation-targets` + +Je nach User Setup in Firewalls / Proxies freischalten. + +jetzt neu: auch ohne performance! + + + + +# Setup Your Other Services + +-> Link to list of supported frameworks/guides or to frameworks/guides with performance enabled. + + + +# Verify + +Screenshots wie es aussehen soll und wo man in Sentry.io es sich ansehen kann. + + + +Von Instrumentationssue auf Trace + +Von Replay auf Trace diff --git a/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx b/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx new file mode 100644 index 0000000000000..513545c7e61a0 --- /dev/null +++ b/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx @@ -0,0 +1,19 @@ +--- +title: Automatic Instrumentation +sidebar_order: 40 +description: "" +supported: + - java + - javascript + - php + - python +--- + +Automatic instrumentation is supported for the following frameworks: + +distributed tracing funktioniert ohne weiter config + + +sucht in HTTP Headern und in Environment Variablen + +-> page ausblenden wenn nicht supported diff --git a/src/platforms/common/distributed-tracing/instrumentation/index.mdx b/src/platforms/common/distributed-tracing/instrumentation/index.mdx new file mode 100644 index 0000000000000..9614abe75489c --- /dev/null +++ b/src/platforms/common/distributed-tracing/instrumentation/index.mdx @@ -0,0 +1,10 @@ +--- +title: Instrumentation +sidebar_order: 40 +description: "" +supported: + - java + - javascript + - php + - python +--- diff --git a/src/platforms/common/distributed-tracing/instrumentation/manual-instrumentation.mdx b/src/platforms/common/distributed-tracing/instrumentation/manual-instrumentation.mdx new file mode 100644 index 0000000000000..6ff134c42087b --- /dev/null +++ b/src/platforms/common/distributed-tracing/instrumentation/manual-instrumentation.mdx @@ -0,0 +1,22 @@ +--- +title: Manual Instrumentation +sidebar_order: 40 +description: "" +supported: + - java + - javascript + - php + - python +--- + + + +todo: codesample wie man sie einliest + + "continue_trace", -> dem kann man den wert des incoming headers übergeben + + +todo: codesample wie man sie weitergibt + + "get_traceparent", -> returned trace header (incl sample decision) + "get_baggage",-> returned baggage header From cd63c8fc46e189d4c4cb06edab74a8ec1f31e099 Mon Sep 17 00:00:00 2001 From: "getsantry[bot]" <66042841+getsantry[bot]@users.noreply.github.com> Date: Thu, 15 Jun 2023 11:34:45 +0000 Subject: [PATCH 003/116] style(lint): Auto commit lint changes --- .../common/distributed-tracing/index.mdx | 15 +++------------ 1 file changed, 3 insertions(+), 12 deletions(-) diff --git a/src/platforms/common/distributed-tracing/index.mdx b/src/platforms/common/distributed-tracing/index.mdx index 137900b71979b..bc0262de72c4d 100644 --- a/src/platforms/common/distributed-tracing/index.mdx +++ b/src/platforms/common/distributed-tracing/index.mdx @@ -34,18 +34,16 @@ Ab welcher Version ist es supported? - tornado - trytond - # Configure Es gibt zwei header -* `sentry-trace` -* `baggage` +- `sentry-trace` +- `baggage` TODO: header beschreiben beispiel header anzeigen - Config fürs limitieren auf gewisse hosts `trace-propagation-targets` @@ -53,21 +51,14 @@ Je nach User Setup in Firewalls / Proxies freischalten. jetzt neu: auch ohne performance! - - - # Setup Your Other Services --> Link to list of supported frameworks/guides or to frameworks/guides with performance enabled. - - +-> Link to list of supported frameworks/guides or to frameworks/guides with performance enabled. # Verify Screenshots wie es aussehen soll und wo man in Sentry.io es sich ansehen kann. - - Von Instrumentationssue auf Trace Von Replay auf Trace From f80799bbc58190c6ed9d5663d42b2d01c70ffeda Mon Sep 17 00:00:00 2001 From: "getsantry[bot]" <66042841+getsantry[bot]@users.noreply.github.com> Date: Thu, 15 Jun 2023 11:34:46 +0000 Subject: [PATCH 004/116] style(lint): Auto commit lint changes --- .../instrumentation/manual-instrumentation.mdx | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/platforms/common/distributed-tracing/instrumentation/manual-instrumentation.mdx b/src/platforms/common/distributed-tracing/instrumentation/manual-instrumentation.mdx index 6ff134c42087b..bcafb2d5bd7da 100644 --- a/src/platforms/common/distributed-tracing/instrumentation/manual-instrumentation.mdx +++ b/src/platforms/common/distributed-tracing/instrumentation/manual-instrumentation.mdx @@ -9,13 +9,10 @@ supported: - python --- - - todo: codesample wie man sie einliest "continue_trace", -> dem kann man den wert des incoming headers übergeben - todo: codesample wie man sie weitergibt "get_traceparent", -> returned trace header (incl sample decision) From 0dd89f237e121559b63a1d3394a96911e1daaf56 Mon Sep 17 00:00:00 2001 From: "getsantry[bot]" <66042841+getsantry[bot]@users.noreply.github.com> Date: Thu, 15 Jun 2023 11:36:22 +0000 Subject: [PATCH 005/116] style(lint): Auto commit lint changes --- .../instrumentation/automatic-instrumentation.mdx | 1 - 1 file changed, 1 deletion(-) diff --git a/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx b/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx index 513545c7e61a0..9d0cd926f6741 100644 --- a/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx +++ b/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx @@ -13,7 +13,6 @@ Automatic instrumentation is supported for the following frameworks: distributed tracing funktioniert ohne weiter config - sucht in HTTP Headern und in Environment Variablen -> page ausblenden wenn nicht supported From 5a2fb8fbdc97f90e5a773a4384569685a4bc4054 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Thu, 15 Jun 2023 13:43:06 +0200 Subject: [PATCH 006/116] Updated suppported frameworks --- .../common/distributed-tracing/index.mdx | 40 ++++++++++++------- 1 file changed, 25 insertions(+), 15 deletions(-) diff --git a/src/platforms/common/distributed-tracing/index.mdx b/src/platforms/common/distributed-tracing/index.mdx index bc0262de72c4d..17b33d9037c89 100644 --- a/src/platforms/common/distributed-tracing/index.mdx +++ b/src/platforms/common/distributed-tracing/index.mdx @@ -17,22 +17,32 @@ Ab welcher Version ist es supported? # Supported frameworks -- aiohttp -- aws_lambda -- bottle -- celery -- django -- falcon -- fastapi -- flask -- gcp -- pyramid -- quart +- Django +- FastAPI +- Flask + +- Bottle +- Falcon +- Pyramid +- Quart +- Starlette +- Starlite +- Tornado + + # Configure From 7607580d7cb00ac3ca3c5f4d465860d2011787e1 Mon Sep 17 00:00:00 2001 From: Stephanie Anderson Date: Thu, 15 Jun 2023 13:42:51 +0200 Subject: [PATCH 007/116] troubleshooting page --- .../common/distributed-tracing/troubleshooting.mdx | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 src/platforms/common/distributed-tracing/troubleshooting.mdx diff --git a/src/platforms/common/distributed-tracing/troubleshooting.mdx b/src/platforms/common/distributed-tracing/troubleshooting.mdx new file mode 100644 index 0000000000000..c74956c798134 --- /dev/null +++ b/src/platforms/common/distributed-tracing/troubleshooting.mdx @@ -0,0 +1,10 @@ +--- +title: Troubleshooting +sidebar_order: 99 +description: "" +supported: + - java + - javascript + - php + - python +--- From 2a9659c279988db91e8e90d7ca4b1dacc6ae1812 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Thu, 15 Jun 2023 14:12:02 +0200 Subject: [PATCH 008/116] Some manual instrumentation docs --- .../manual-instrumentation.mdx | 45 ++++++++++++++++--- 1 file changed, 40 insertions(+), 5 deletions(-) diff --git a/src/platforms/common/distributed-tracing/instrumentation/manual-instrumentation.mdx b/src/platforms/common/distributed-tracing/instrumentation/manual-instrumentation.mdx index bcafb2d5bd7da..0ca6207185294 100644 --- a/src/platforms/common/distributed-tracing/instrumentation/manual-instrumentation.mdx +++ b/src/platforms/common/distributed-tracing/instrumentation/manual-instrumentation.mdx @@ -9,11 +9,46 @@ supported: - python --- -todo: codesample wie man sie einliest +Distributed tracing works out of the box for the following frameworks: Django, FastAPI, Flask, Bottle, Falcon, Pyramid, Quart, Starlette, Starlite, Tornado. - "continue_trace", -> dem kann man den wert des incoming headers übergeben +If you are using one of the frameworks listed, you do not need to do anything for distributed tracing to work! You can now stop reading this page and continue building and amazing product. -todo: codesample wie man sie weitergibt +If you have a vanilla Python project or use an unsupported framework you can still add distributed tracing to your project but need to it "by hand". - "get_traceparent", -> returned trace header (incl sample decision) - "get_baggage",-> returned baggage header +Two things need to be done for distributed tracing to work: + +- When receiving incoming requests, parse incoming tracing information. +- When doing outgoing requests, add tracing information to. + +## Parse incoming tracing information + +Incoming tracing information has to be saved +Incoming tracing can come from different places. In a web environment it will be sent with HTTP headers, if you are in a job queue (like Celery or rq, the tracing information can be set in some meta or header variables.) You also can pick up tracing information from environment variables. + +```python +import sentry_sdk + +headers = get_incoming_headers_as_dict() + +sentry_sdk.continue_trace(headers) +``` + +This will parse the headers and try to find the `sentry-trace` and `baggage` headers and stores them for later use. + +## Add tracing information to outgoing requests + +On outgoing requests to have to add the two headers `sentry-trace` and `baggage` that you parsed and stored earlier. + +If you are doing your http requests with `requests` or `aiohttp` (or even the low level `http.client` (or `httplib` on older Pythons)) the parsed and stored headers are added automatically. You do not need to do anything! + +If you do outgoing requests in another way you can prepare the headers like follows: + +```python +import sentry_sdk + +headers = {} +headers["sentry-trace"] = sentry_sdk.get_traceparent() +headers["baggage"] = sentry_sdk.get_baggage() + +do_an_outgoing_request("https://example.com", headers=headers) +``` From 0a68f914218be52be8ce679bc6a697392e63dd2e Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Thu, 15 Jun 2023 14:35:48 +0200 Subject: [PATCH 009/116] wording --- .../instrumentation/manual-instrumentation.mdx | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/platforms/common/distributed-tracing/instrumentation/manual-instrumentation.mdx b/src/platforms/common/distributed-tracing/instrumentation/manual-instrumentation.mdx index 0ca6207185294..40e024bdaaa01 100644 --- a/src/platforms/common/distributed-tracing/instrumentation/manual-instrumentation.mdx +++ b/src/platforms/common/distributed-tracing/instrumentation/manual-instrumentation.mdx @@ -9,7 +9,7 @@ supported: - python --- -Distributed tracing works out of the box for the following frameworks: Django, FastAPI, Flask, Bottle, Falcon, Pyramid, Quart, Starlette, Starlite, Tornado. +Distributed tracing works out of the box for the following frameworks: Django, FastAPI, Flask, Bottle, Falcon, Pyramid, Quart, Starlette, Starlite, Tornado. If you are using one of the frameworks listed, you do not need to do anything for distributed tracing to work! You can now stop reading this page and continue building and amazing product. @@ -27,28 +27,30 @@ Incoming tracing can come from different places. In a web environment it will be ```python import sentry_sdk +from my_project import get_incoming_headers_as_dict headers = get_incoming_headers_as_dict() sentry_sdk.continue_trace(headers) ``` -This will parse the headers and try to find the `sentry-trace` and `baggage` headers and stores them for later use. +This will parse the given headers and try to find the `sentry-trace` and `baggage` headers and it will store them for later use. ## Add tracing information to outgoing requests On outgoing requests to have to add the two headers `sentry-trace` and `baggage` that you parsed and stored earlier. -If you are doing your http requests with `requests` or `aiohttp` (or even the low level `http.client` (or `httplib` on older Pythons)) the parsed and stored headers are added automatically. You do not need to do anything! +If you are doing your HTTP requests with [Requests](https://requests.readthedocs.io/en/latest/), [AIOHTTP](https://docs.aiohttp.org/en/stable/), the low level [http.client](https://docs.python.org/3/library/http.client.html), or even [httplib](https://docs.python.org/2/library/httplib.html) on Pyton 2 the parsed and stored headers are added automatically added to outgoing requests. You do not need to do anything! If you do outgoing requests in another way you can prepare the headers like follows: ```python import sentry_sdk +from my_project import make_an_outgoing_request headers = {} headers["sentry-trace"] = sentry_sdk.get_traceparent() headers["baggage"] = sentry_sdk.get_baggage() -do_an_outgoing_request("https://example.com", headers=headers) +make_an_outgoing_request(to="https://example.com", headers=headers) ``` From 1dbe164028dbbe33896836fb8d7cb40dd5458e66 Mon Sep 17 00:00:00 2001 From: Manoel Aranda Neto <5731772+marandaneto@users.noreply.github.com> Date: Thu, 15 Jun 2023 13:47:35 +0200 Subject: [PATCH 010/116] Document Apollo3 GraphQL client errors (#7135) --- .../configuration/integrations/apollo3.mdx | 89 ++++++++++++++++++- 1 file changed, 88 insertions(+), 1 deletion(-) diff --git a/src/platforms/android/configuration/integrations/apollo3.mdx b/src/platforms/android/configuration/integrations/apollo3.mdx index 9764da9cef028..2d134fc16891f 100644 --- a/src/platforms/android/configuration/integrations/apollo3.mdx +++ b/src/platforms/android/configuration/integrations/apollo3.mdx @@ -32,7 +32,8 @@ Add `Interceptors` to `ApolloClient.Builder` using `ApolloBuilderExtensions`: import com.apollographql.apollo3.ApolloClient; import io.sentry.apollo3.SentryApolloBuilderExtensionsKt; -ApolloClient apollo = SentryApolloBuilderExtensionsKt.sentryTracing(new ApolloClient.Builder()) +ApolloClient apollo = SentryApolloBuilderExtensionsKt + .sentryTracing(new ApolloClient.Builder()) .serverUrl("https://your-api-host/") .build(); ``` @@ -118,3 +119,89 @@ val apollo = ApolloClient.builder() } .build() ``` + +## GraphQL Client Errors + +Once enabled, this feature will automatically capture GraphQL client errors such as bad operations and response codes, and report them to Sentry as error events. Each error event will contain the `request` and `response` data, including the `url`, `status_code`, and `data` (stringified `query`). + +Sentry will group GraphQL client errors by the `operationName`, `operationType`, and `statusCode`, so that you can easily see the number of errors that happened for each. + +This is an opt-in feature and can be enabled by setting the `captureFailedRequests` option to `true`: + +```kotlin +import com.apollographql.apollo3.ApolloClient +import io.sentry.apollo3.sentryTracing + +val apollo = ApolloClient.builder() + .serverUrl("https://your-api-host/") + .sentryTracing(captureFailedRequests = true) + .build() +``` + +By default, only GraphQL client errors with a response that includes the [errors](https://spec.graphql.org/October2021/#sec-Errors) array will be captured as error events. + +GraphQL client errors from every target (`.*` regular expression) are automatically captured, but you can change this behavior by setting the `failedRequestTargets` option with either a regular expression or a plain `String`. A plain string must contain at least one of the items from the list. Plain strings don't have to be full matches, meaning the URL of a request is matched when it contains a string provided through the option. + +```kotlin +import com.apollographql.apollo3.ApolloClient +import io.sentry.apollo3.sentryTracing + +val apollo = ApolloClient.builder() + .serverUrl("https://your-api-host/") + .sentryTracing(captureFailedRequests = true, failedRequestTargets = listOf("myapi.com")) + .build() +``` + +By default, error events won't contain `Headers` or `Cookies`, but you can change this behavior by setting the `sendDefaultPii` option to `true`: + +```xml {filename:AndroidManifest.xml} + + + +``` + +Error events will contain the raw bodies of GraphQL requests and responses, which may include sensitive data. To avoid this, parameterize your queries using the [variables](https://spec.graphql.org/October2021/#sec-Language.Variables) field. [Relay](/product/relay) will then run [PII Data Scrubbing](/product/relay/#pii-data-scrubbing), automatically transforming values into `[Filtered]`. + +Alternatively, you can customize the event and scrub the data yourself. + +### Customize or Drop the Error Event + +To customize or drop the error event, you'll need to do a [manual initialization](/platforms/android/configuration/manual-init/) of the Sentry Android SDK. The captured error event can then be customized or dropped with a `BeforeSendCallback`: + +```kotlin +import io.sentry.android.core.SentryAndroid +import io.sentry.SentryOptions.BeforeSendCallback +import com.apollographql.apollo3.api.http.HttpRequest +import com.apollographql.apollo3.api.http.HttpResponse +import io.sentry.TypeCheckHint.APOLLO_REQUEST +import io.sentry.TypeCheckHint.APOLLO_RESPONSE + +SentryAndroid.init(this) { options -> + // Add a callback that will be used before the event is sent to Sentry. + // With this callback, you can modify the event or, when returning null, also discard the event. + options.beforeSend = BeforeSendCallback { event, hint -> + val request = hint.getAs(APOLLO_REQUEST, HttpRequest::class.java) + val response = hint.getAs(APOLLO_RESPONSE, HttpResponse::class.java) + + // customize or drop the event + event + } +} +``` + +### Automatically and Manually Captured GraphQL Client Errors + +When `captureFailedRequests` is enabled, some GraphQL client libraries will throw unchecked exceptions, such as the `ApolloException` and its implementations. This means the error event will be captured by both the GraphQL client library and the Sentry Android SDK. To avoid this, we recommend identifying these errors and using the `Sentry.captureException` method instead of capturing them manually: + +```kotlin +import io.sentry.Sentry +import com.apollographql.apollo3.exception.ApolloException + +try { + // If this API call returns the `errors` array, it will be captured as an error event by the `SentryApollo3HttpInterceptor`. + return apolloClient.query(LaunchDetailsQuery(launchId)).execute() +} catch (e: ApolloException) { + // Do not manually capture this exception to avoid duplicated error events. + // Sentry.captureException(e) +} +``` From e10a2a61a284c0e630349ff4573102aefa5e575d Mon Sep 17 00:00:00 2001 From: Liza Mock Date: Thu, 15 Jun 2023 04:48:17 -0700 Subject: [PATCH 011/116] Update apollo3.mdx (#7150) --- .../android/configuration/integrations/apollo3.mdx | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/platforms/android/configuration/integrations/apollo3.mdx b/src/platforms/android/configuration/integrations/apollo3.mdx index 2d134fc16891f..9a4a7093a7e78 100644 --- a/src/platforms/android/configuration/integrations/apollo3.mdx +++ b/src/platforms/android/configuration/integrations/apollo3.mdx @@ -10,14 +10,16 @@ categories: -Capturing transactions requires that you first set up performance monitoring if you haven't already. +To be able to capture transactions, you'll need to first set up performance monitoring. -Sentry Apollo3 integration provides the `SentryApollo3Interceptor` and the `SentryApollo3HttpInterceptor`, which create a span for each outgoing HTTP request executed with an [Apollo Kotlin](https://github.com/apollographql/apollo-kotlin) GraphQL client. For easier usage, the integration also provides extension functions on the `ApolloClient.Builder`. +Sentry's Apollo3 integration provides both the `SentryApollo3Interceptor` and the `SentryApollo3HttpInterceptor`, which create a span for each outgoing HTTP request executed with an [Apollo Kotlin](https://github.com/apollographql/apollo-kotlin) GraphQL client. The integration also provides extension functions on the `ApolloClient.Builder`. ## Install +To install Apollo3: + ```groovy {tabTitle:Gradle} implementation 'io.sentry:sentry-apollo-3:{{@inject packages.version('sentry.java.apollo-3', '6.1.4') }}' ``` @@ -50,7 +52,7 @@ val apollo = ApolloClient.builder() ## Manual Configuration -When using a custom `NetworkTransport`, the `SentryInterceptors` need to be added manually, because `HttpInterceptors` need to be added to the `NetworkTransport`: +Because `HttpInterceptors` need to be added to the `NetworkTransport`, the `SentryInterceptors` need to be added manually if you're using a custom `NetworkTransport`: ```java import com.apollographql.apollo3.ApolloClient; From 328ce33298138fca0ec41f4400971b9524876102 Mon Sep 17 00:00:00 2001 From: Liza Mock Date: Thu, 15 Jun 2023 04:48:28 -0700 Subject: [PATCH 012/116] Update Apollo3.mdx for Java to match the one for Android (#7165) --- .../common/performance/instrumentation/apollo3.mdx | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/platforms/java/common/performance/instrumentation/apollo3.mdx b/src/platforms/java/common/performance/instrumentation/apollo3.mdx index c49e469d95e3d..87417240df713 100644 --- a/src/platforms/java/common/performance/instrumentation/apollo3.mdx +++ b/src/platforms/java/common/performance/instrumentation/apollo3.mdx @@ -10,14 +10,16 @@ notSupported: -Capturing transactions requires that you first set up performance monitoring if you haven't already. +To be able to capture transactions, you'll need to first set up performance monitoring. -Sentry Apollo3 integration provides the `SentryApollo3Interceptor` and the `SentryApollo3HttpInterceptor`, which create a span for each outgoing HTTP request executed with an [Apollo Kotlin](https://github.com/apollographql/apollo-kotlin) GraphQL client. For easier usage, the integration also provides extension functions on the `ApolloClient.Builder`. +Sentry's Apollo3 integration provides both the `SentryApollo3Interceptor` and the `SentryApollo3HttpInterceptor`, which create a span for each outgoing HTTP request executed with an [Apollo Kotlin](https://github.com/apollographql/apollo-kotlin) GraphQL client. The integration also provides extension functions on the `ApolloClient.Builder`. ## Install +To install Apollo3: + ```xml {tabTitle:Maven} io.sentry @@ -61,7 +63,7 @@ val apollo = ApolloClient.builder() ## Manual Configuration -When using a custom `NetworkTransport`, the `SentryInterceptors` need to be added manually, because `HttpInterceptors` need to be added to the `NetworkTransport`: +Because `HttpInterceptors` need to be added to the `NetworkTransport`, the `SentryInterceptors` have to be added manually if you're using a custom `NetworkTransport`: ```java import com.apollographql.apollo3.ApolloClient; @@ -122,7 +124,7 @@ In Global Hub Mode, all threads use the same Hub. ## Using With Kotlin Coroutines -To make sure that a coroutine has access to the correct Sentry context, provide an instance of `SentryContext` when launching a coroutine: +Make sure that your coroutine has access to the correct Sentry context when launching, by providing an instance of `SentryContext`: ```kotlin import com.apollographql.apollo3.ApolloClient From 4e871ebd92b2b6d7b62ca37623939095330dd302 Mon Sep 17 00:00:00 2001 From: Stephanie Anderson Date: Thu, 15 Jun 2023 14:31:44 +0200 Subject: [PATCH 013/116] unify wording for custom integration (manual vs. custom) (#7179) --- src/docs/product/profiling/index.mdx | 4 ++-- .../performance/configure-sample-rate/javascript.mdx | 2 +- .../performance/configure-sample-rate/javascript.react.mdx | 2 +- .../performance/configure-sample-rate/javascript.vue.mdx | 2 +- .../performance/instrumentation/automatic-instrumentation.mdx | 4 ++-- src/platforms/android/configuration/integrations/file-io.mdx | 2 +- .../android/configuration/integrations/room-and-sqlite.mdx | 2 +- .../performance/instrumentation/automatic-instrumentation.mdx | 2 +- src/platforms/common/configuration/options.mdx | 2 +- .../integrations/user-interaction-instrumentation.mdx | 2 +- .../instrumentation/user-interaction-instrumentation.mdx | 2 +- 11 files changed, 13 insertions(+), 13 deletions(-) diff --git a/src/docs/product/profiling/index.mdx b/src/docs/product/profiling/index.mdx index be5c0ef2eae4c..91c98caffa663 100644 --- a/src/docs/product/profiling/index.mdx +++ b/src/docs/product/profiling/index.mdx @@ -3,7 +3,7 @@ title: "Profiling" sidebar_order: 50 redirect_from: - /profiling/ -description: "Profiling offers a deeper level of visibility on top of traditional tracing, removing the need for manual instrumentation and enabling precise code-level visibility into your application in a production environment." +description: "Profiling offers a deeper level of visibility on top of traditional tracing, removing the need for custom instrumentation and enabling precise code-level visibility into your application in a production environment." --- @@ -20,7 +20,7 @@ description: "Profiling offers a deeper level of visibility on top of traditiona -Profiling offers a deeper level of visibility on top of traditional tracing, removing the need for manual instrumentation and enabling you to build in [performance as a feature](https://blog.codinghorror.com/performance-is-a-feature/) from day one. Sentry's profiling feature builds upon our established [Performance Monitoring](/product/performance) capabilities to provide precise code-level visibility into application execution in a production environment. This allows you to quickly identify potential performance bottlenecks and visualize the call stack to find hot paths in your code. +Profiling offers a deeper level of visibility on top of traditional tracing, removing the need for custom instrumentation and enabling you to build in [performance as a feature](https://blog.codinghorror.com/performance-is-a-feature/) from day one. Sentry's profiling feature builds upon our established [Performance Monitoring](/product/performance) capabilities to provide precise code-level visibility into application execution in a production environment. This allows you to quickly identify potential performance bottlenecks and visualize the call stack to find hot paths in your code. Sentry profiling supports common platforms for both Mobile and Backend applications: diff --git a/src/platform-includes/performance/configure-sample-rate/javascript.mdx b/src/platform-includes/performance/configure-sample-rate/javascript.mdx index 6d322b84ebe80..d37d9eea6ddd2 100644 --- a/src/platform-includes/performance/configure-sample-rate/javascript.mdx +++ b/src/platform-includes/performance/configure-sample-rate/javascript.mdx @@ -8,7 +8,7 @@ Sentry.init({ // This enables automatic instrumentation (highly recommended), // but is not necessary for purely manual usage - // If you only want to use manual instrumentation: + // If you only want to use custom instrumentation: // * Remove the `BrowserTracing` integration // * add `Sentry.addTracingExtensions()` above your Sentry.init() call integrations: [ diff --git a/src/platform-includes/performance/configure-sample-rate/javascript.react.mdx b/src/platform-includes/performance/configure-sample-rate/javascript.react.mdx index 851ea424f2d0a..7cede1adae3a4 100644 --- a/src/platform-includes/performance/configure-sample-rate/javascript.react.mdx +++ b/src/platform-includes/performance/configure-sample-rate/javascript.react.mdx @@ -6,7 +6,7 @@ Sentry.init({ dsn: "___PUBLIC_DSN___", // This enables automatic instrumentation (highly recommended) - // If you only want to use manual instrumentation: + // If you only want to use custom instrumentation: // * Remove the `BrowserTracing` integration // * add `Sentry.addTracingExtensions()` above your Sentry.init() call integrations: [ diff --git a/src/platform-includes/performance/configure-sample-rate/javascript.vue.mdx b/src/platform-includes/performance/configure-sample-rate/javascript.vue.mdx index c950b8bbee3b4..18be5b12fb114 100644 --- a/src/platform-includes/performance/configure-sample-rate/javascript.vue.mdx +++ b/src/platform-includes/performance/configure-sample-rate/javascript.vue.mdx @@ -9,7 +9,7 @@ Sentry.init({ // This enables automatic instrumentation (highly recommended), // but is not necessary for purely manual usage - // If you only want to use manual instrumentation: + // If you only want to use custom instrumentation: // * Remove the `BrowserTracing` integration // * add `Sentry.addTracingExtensions()` above your Sentry.init() call integrations: [ diff --git a/src/platforms/android/common/performance/instrumentation/automatic-instrumentation.mdx b/src/platforms/android/common/performance/instrumentation/automatic-instrumentation.mdx index 3a1478b19572b..c442855f890df 100644 --- a/src/platforms/android/common/performance/instrumentation/automatic-instrumentation.mdx +++ b/src/platforms/android/common/performance/instrumentation/automatic-instrumentation.mdx @@ -58,7 +58,7 @@ span?.finish() In case that the user left this Activity before you've finished the transaction manually, the SDK finishes the transaction automatically when the `onDestroy` method is called. -Transactions are always bound to the Scope automatically if there's none set. Because of that, you may create spans using manual instrumentation, and those spans will be automatically associated with the Activity's running transaction. +Transactions are always bound to the Scope automatically if there's none set. Because of that, you may create spans using custom instrumentation, and those spans will be automatically associated with the Activity's running transaction. ```java import java.lang.Exception; @@ -329,7 +329,7 @@ span?.finish() If the host `Activity` transitions into a non-interactive state (for example, `onPause`), the UI transaction will be scheduled to finish automatically (as soon as all of its child spans are finished). -Transactions are always bound to the `Scope` automatically if there's none set. Because of that, you can create spans using manual instrumentation, and those spans will be automatically associated with the running UI transaction. +Transactions are always bound to the `Scope` automatically if there's none set. Because of that, you can create spans using custom instrumentation, and those spans will be automatically associated with the running UI transaction. ```java import java.lang.Exception; diff --git a/src/platforms/android/configuration/integrations/file-io.mdx b/src/platforms/android/configuration/integrations/file-io.mdx index f158f0eb45e28..db93c6e07e702 100644 --- a/src/platforms/android/configuration/integrations/file-io.mdx +++ b/src/platforms/android/configuration/integrations/file-io.mdx @@ -133,7 +133,7 @@ At the moment, we only support `java.io.FileInputStream`, `java.io.FileOutputStr -## (Optional) Manual Instrumentation +## (Optional) Custom Instrumentation Alternatively, if you are not using our Gradle Plugin, the Android SDK provides the capability to manually instrument file I/O operations through the custom Sentry-specific implementations. diff --git a/src/platforms/android/configuration/integrations/room-and-sqlite.mdx b/src/platforms/android/configuration/integrations/room-and-sqlite.mdx index 77ace1177d915..b5cc42cf53c05 100644 --- a/src/platforms/android/configuration/integrations/room-and-sqlite.mdx +++ b/src/platforms/android/configuration/integrations/room-and-sqlite.mdx @@ -14,7 +14,7 @@ Supported in Sentry's Android SDK version `4.0.0` and above. Supported in Sentry Android Gradle Plugin version `3.0.0` and above. -Manual instrumentation is supported in Sentry's Android SDK, version `6.21.0` and above. +Custom instrumentation is supported in Sentry's Android SDK, version `6.21.0` and above. diff --git a/src/platforms/apple/common/performance/instrumentation/automatic-instrumentation.mdx b/src/platforms/apple/common/performance/instrumentation/automatic-instrumentation.mdx index e393a32733348..337fb3d32c69e 100644 --- a/src/platforms/apple/common/performance/instrumentation/automatic-instrumentation.mdx +++ b/src/platforms/apple/common/performance/instrumentation/automatic-instrumentation.mdx @@ -284,7 +284,7 @@ If the UI transaction has idled but didn't have any child spans added, the SDK w -The SDK binds user interaction transactions to the `Scope` automatically if there's no other transaction set. Because of that, you can create spans using manual instrumentation, and those spans will be automatically associated with the running UI transaction. +The SDK binds user interaction transactions to the `Scope` automatically if there's no other transaction set. Because of that, you can create spans using custom instrumentation, and those spans will be automatically associated with the running UI transaction. ```Swift import Sentry diff --git a/src/platforms/common/configuration/options.mdx b/src/platforms/common/configuration/options.mdx index ebcf05a8c1a57..71dc53596df50 100644 --- a/src/platforms/common/configuration/options.mdx +++ b/src/platforms/common/configuration/options.mdx @@ -877,7 +877,7 @@ If is not provided, trac An optional list of functions that should be set up for performance monitoring. For each function in the list, a span will be created when the function is executed. Functions in the list are represented as strings containing the fully qualified name of the function. -This is a convenient option, making it possible to have one central place for configuring what functions to trace, instead of having manual instrumentation scattered all over your code base. +This is a convenient option, making it possible to have one central place for configuring what functions to trace, instead of having custom instrumentation scattered all over your code base. To learn more, see the [Custom Instrumentation](/platforms/python/performance/instrumentation/custom-instrumentation/#define-span-creation-in-a-central-place) documentation. diff --git a/src/platforms/flutter/common/configuration/integrations/user-interaction-instrumentation.mdx b/src/platforms/flutter/common/configuration/integrations/user-interaction-instrumentation.mdx index ea7eaeaa6b22f..c1679612c7df1 100644 --- a/src/platforms/flutter/common/configuration/integrations/user-interaction-instrumentation.mdx +++ b/src/platforms/flutter/common/configuration/integrations/user-interaction-instrumentation.mdx @@ -57,7 +57,7 @@ final span = Sentry.getSpan() await span?.finish(); ``` -Transactions are always bound to the `Scope` automatically if there's none set. Because of that, you can create spans using manual instrumentation, and those spans will be automatically associated with the running UI transaction. +Transactions are always bound to the `Scope` automatically if there's none set. Because of that, you can create spans using custom instrumentation, and those spans will be automatically associated with the running UI transaction. ```dart import 'package:sentry/sentry.dart'; diff --git a/src/platforms/react-native/performance/instrumentation/user-interaction-instrumentation.mdx b/src/platforms/react-native/performance/instrumentation/user-interaction-instrumentation.mdx index ca4f86277ba97..a1495d93c8051 100644 --- a/src/platforms/react-native/performance/instrumentation/user-interaction-instrumentation.mdx +++ b/src/platforms/react-native/performance/instrumentation/user-interaction-instrumentation.mdx @@ -54,7 +54,7 @@ export default Sentry.wrap(App, { dropped. -Because transactions are automatically bound to scope, you can create child spans using [manual instrumentation](/platforms/react-native/performance/instrumentation/custom-instrumentation/#retrieve-a-transaction). Note, that the `idleTimeoout` for running UI transactions defaults to `1000` milliseconds (one second). +Because transactions are automatically bound to scope, you can create child spans using [custom instrumentation](/platforms/react-native/performance/instrumentation/custom-instrumentation/#retrieve-a-transaction). Note, that the `idleTimeoout` for running UI transactions defaults to `1000` milliseconds (one second). ## Gesture Events From d254b4f3d4d4804e40f38ef2fac022710764e5b4 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Thu, 15 Jun 2023 14:59:07 +0200 Subject: [PATCH 014/116] Renamed page and some wording --- .../manual-instrumentation.mdx | 56 ------------------- 1 file changed, 56 deletions(-) delete mode 100644 src/platforms/common/distributed-tracing/instrumentation/manual-instrumentation.mdx diff --git a/src/platforms/common/distributed-tracing/instrumentation/manual-instrumentation.mdx b/src/platforms/common/distributed-tracing/instrumentation/manual-instrumentation.mdx deleted file mode 100644 index 40e024bdaaa01..0000000000000 --- a/src/platforms/common/distributed-tracing/instrumentation/manual-instrumentation.mdx +++ /dev/null @@ -1,56 +0,0 @@ ---- -title: Manual Instrumentation -sidebar_order: 40 -description: "" -supported: - - java - - javascript - - php - - python ---- - -Distributed tracing works out of the box for the following frameworks: Django, FastAPI, Flask, Bottle, Falcon, Pyramid, Quart, Starlette, Starlite, Tornado. - -If you are using one of the frameworks listed, you do not need to do anything for distributed tracing to work! You can now stop reading this page and continue building and amazing product. - -If you have a vanilla Python project or use an unsupported framework you can still add distributed tracing to your project but need to it "by hand". - -Two things need to be done for distributed tracing to work: - -- When receiving incoming requests, parse incoming tracing information. -- When doing outgoing requests, add tracing information to. - -## Parse incoming tracing information - -Incoming tracing information has to be saved -Incoming tracing can come from different places. In a web environment it will be sent with HTTP headers, if you are in a job queue (like Celery or rq, the tracing information can be set in some meta or header variables.) You also can pick up tracing information from environment variables. - -```python -import sentry_sdk -from my_project import get_incoming_headers_as_dict - -headers = get_incoming_headers_as_dict() - -sentry_sdk.continue_trace(headers) -``` - -This will parse the given headers and try to find the `sentry-trace` and `baggage` headers and it will store them for later use. - -## Add tracing information to outgoing requests - -On outgoing requests to have to add the two headers `sentry-trace` and `baggage` that you parsed and stored earlier. - -If you are doing your HTTP requests with [Requests](https://requests.readthedocs.io/en/latest/), [AIOHTTP](https://docs.aiohttp.org/en/stable/), the low level [http.client](https://docs.python.org/3/library/http.client.html), or even [httplib](https://docs.python.org/2/library/httplib.html) on Pyton 2 the parsed and stored headers are added automatically added to outgoing requests. You do not need to do anything! - -If you do outgoing requests in another way you can prepare the headers like follows: - -```python -import sentry_sdk -from my_project import make_an_outgoing_request - -headers = {} -headers["sentry-trace"] = sentry_sdk.get_traceparent() -headers["baggage"] = sentry_sdk.get_baggage() - -make_an_outgoing_request(to="https://example.com", headers=headers) -``` From 0fdc1868e4e128a0bfb1c8316d5e42c5bd134123 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Thu, 15 Jun 2023 15:05:28 +0200 Subject: [PATCH 015/116] Links to supported frameworks --- .../common/distributed-tracing/index.mdx | 21 +++++++++---------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/src/platforms/common/distributed-tracing/index.mdx b/src/platforms/common/distributed-tracing/index.mdx index 17b33d9037c89..5f0f25aa256ca 100644 --- a/src/platforms/common/distributed-tracing/index.mdx +++ b/src/platforms/common/distributed-tracing/index.mdx @@ -17,17 +17,16 @@ Ab welcher Version ist es supported? # Supported frameworks -- Django -- FastAPI -- Flask - -- Bottle -- Falcon -- Pyramid -- Quart -- Starlette -- Starlite -- Tornado +- [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/) +- [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/) +- [Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/) +- [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/) +- [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/) +- [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/) +- [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/) +- [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/) +- [Starlite](/platforms/python/guides/starlite/distributed-tracing/instrumentation/automatic-instrumentation/) +- [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/) # Configure From d99609f3a065ca3a792a756dc231ae4fbe754363 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Thu, 15 Jun 2023 15:26:16 +0200 Subject: [PATCH 018/116] Added missing file --- .../automatic-instrumentation.mdx | 41 +++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 src/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation.mdx diff --git a/src/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation.mdx b/src/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation.mdx new file mode 100644 index 0000000000000..fe1f36d2a2fba --- /dev/null +++ b/src/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation.mdx @@ -0,0 +1,41 @@ +--- +title: Automatic Instrumentation +sidebar_order: 40 +description: "" +supported: + - python.django +--- + +If you run a Django project distributed tracing works out of the box. If requests to your Django project include the `sentry-trace` and `baggage` headers they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. + +You just need to initialize the Sentry SDK in your `settings.py` file and you are good to go. + +```python +import sentry_sdk + +sentry_sdk.init( + dsn="___PUBLIC_DSN___", + # ... +) +``` + +## Configuration + +By default trace information (`sentry-trace` and `baggage` headers) will be added to **all** outgoing HTTP requests. If you want to limit to what URLs the trace information should be added you can specify an `trace_propagation_targets` option: + +```python +import sentry_sdk +from sentry_sdk.integrations.django import DjangoIntegration + +sentry_sdk.init( + dsn="___PUBLIC_DSN___", + trace_propagation_targets=[ + "https://myproject.org", + r"https://.*\.otherservice.org/.*", + ] +) +``` + +In this example trace information will be added to all requests to URLs that contain `"https://myproject.org"` or to all ULRs of all sub domains of `otherservice.org` like `https://api.otherservice.org/something/`, `https://payment.otherservice.org/something/` and so on. + +See `trace_propagation_targets` documentation for more information. From 130141c3ef93e994dc84e820f6ed61c0882eb9bc Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Thu, 15 Jun 2023 15:33:40 +0200 Subject: [PATCH 019/116] Instrumentation index page. --- .../common/distributed-tracing/instrumentation/index.mdx | 4 ++++ .../instrumentation/automatic-instrumentation.mdx | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/src/platforms/common/distributed-tracing/instrumentation/index.mdx b/src/platforms/common/distributed-tracing/instrumentation/index.mdx index 9614abe75489c..9b93825bff344 100644 --- a/src/platforms/common/distributed-tracing/instrumentation/index.mdx +++ b/src/platforms/common/distributed-tracing/instrumentation/index.mdx @@ -8,3 +8,7 @@ supported: - php - python --- + +Distributed tracing works out of the box for the following frameworks: [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/), [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/),[Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/), [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/), [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/), [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/), [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlite](/platforms/python/guides/starlite/distributed-tracing/instrumentation/automatic-instrumentation/), [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/). + +If you have a vanilla Python project or use a (yet) unsupported framework you need to set up Custom Instrumentation. diff --git a/src/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation.mdx b/src/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation.mdx index fe1f36d2a2fba..bea4d4d95156d 100644 --- a/src/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation.mdx +++ b/src/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation.mdx @@ -8,7 +8,7 @@ supported: If you run a Django project distributed tracing works out of the box. If requests to your Django project include the `sentry-trace` and `baggage` headers they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. -You just need to initialize the Sentry SDK in your `settings.py` file and you are good to go. +You just need to initialize the Sentry SDK in your `settings.py` file and you are good to go: ```python import sentry_sdk From 94f722f90867ffcaabf28e59b451b154f9f515b6 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Thu, 15 Jun 2023 15:39:03 +0200 Subject: [PATCH 020/116] Wording --- src/platforms/common/distributed-tracing/index.mdx | 2 ++ .../common/distributed-tracing/instrumentation/index.mdx | 2 +- .../instrumentation/automatic-instrumentation.mdx | 2 +- 3 files changed, 4 insertions(+), 2 deletions(-) diff --git a/src/platforms/common/distributed-tracing/index.mdx b/src/platforms/common/distributed-tracing/index.mdx index dd0febd2f7adf..51af840b6c693 100644 --- a/src/platforms/common/distributed-tracing/index.mdx +++ b/src/platforms/common/distributed-tracing/index.mdx @@ -17,6 +17,8 @@ Ab welcher Version ist es supported? # Supported frameworks +In the following frameworks distributed tracing works out of the box: + - [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/) - [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/) - [Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/) diff --git a/src/platforms/common/distributed-tracing/instrumentation/index.mdx b/src/platforms/common/distributed-tracing/instrumentation/index.mdx index 9b93825bff344..2d0dbe8b7c280 100644 --- a/src/platforms/common/distributed-tracing/instrumentation/index.mdx +++ b/src/platforms/common/distributed-tracing/instrumentation/index.mdx @@ -11,4 +11,4 @@ supported: Distributed tracing works out of the box for the following frameworks: [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/), [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/),[Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/), [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/), [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/), [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/), [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlite](/platforms/python/guides/starlite/distributed-tracing/instrumentation/automatic-instrumentation/), [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/). -If you have a vanilla Python project or use a (yet) unsupported framework you need to set up Custom Instrumentation. +If you have a vanilla Python project or use a (yet) unsupported framework you need to implement Custom Instrumentation. diff --git a/src/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation.mdx b/src/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation.mdx index bea4d4d95156d..c3ad422295c1a 100644 --- a/src/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation.mdx +++ b/src/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation.mdx @@ -38,4 +38,4 @@ sentry_sdk.init( In this example trace information will be added to all requests to URLs that contain `"https://myproject.org"` or to all ULRs of all sub domains of `otherservice.org` like `https://api.otherservice.org/something/`, `https://payment.otherservice.org/something/` and so on. -See `trace_propagation_targets` documentation for more information. +See `trace_propagation_targets` documentation for more information about this option. From bec1e01bfaf445e8b1cd67c9bdcf06f883108f8a Mon Sep 17 00:00:00 2001 From: Stephanie Anderson Date: Thu, 15 Jun 2023 16:02:16 +0200 Subject: [PATCH 021/116] move pages and partials --- .../distributed-tracing/index/android.mdx | 7 ++ .../distributed-tracing/index/javascript.mdx | 77 +++++++++++++++++++ .../distributed-tracing/index/node.mdx | 27 +++++++ .../custom-instrumentation/dart.mdx | 21 +++++ .../custom-instrumentation/dotnet.mdx | 51 ++++++++++++ .../custom-instrumentation/java.mdx | 62 +++++++++++++++ .../custom-instrumentation/native.mdx | 43 +++++++++++ .../custom-instrumentation/rust.mdx | 35 +++++++++ .../common/distributed-tracing/index.mdx | 27 +++++-- .../automatic-instrumentation.mdx | 12 +++ .../performance/distributed-tracing.mdx | 25 ------ .../custom-instrumentation.mdx | 10 --- 12 files changed, 357 insertions(+), 40 deletions(-) create mode 100644 src/platform-includes/distributed-tracing/index/android.mdx create mode 100644 src/platform-includes/distributed-tracing/index/javascript.mdx create mode 100644 src/platform-includes/distributed-tracing/index/node.mdx create mode 100644 src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/dart.mdx create mode 100644 src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/dotnet.mdx create mode 100644 src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/java.mdx create mode 100644 src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/native.mdx create mode 100644 src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/rust.mdx delete mode 100644 src/platforms/common/performance/distributed-tracing.mdx diff --git a/src/platform-includes/distributed-tracing/index/android.mdx b/src/platform-includes/distributed-tracing/index/android.mdx new file mode 100644 index 0000000000000..f57c51595d46a --- /dev/null +++ b/src/platform-includes/distributed-tracing/index/android.mdx @@ -0,0 +1,7 @@ +### HTTP and GraphQL Requests + +For traces that begin in the mobile app, any requests made (and any requests your backend makes as a result) are linked through the request header `sentry-trace`. + +The Sentry Android SDK offers [OkHttp](/platforms/android/configuration/integrations/okhttp/) and [Apollo](/platforms/android/configuration/integrations/apollo/) integrations for HTTP and GraphQL requests respectively. + +These integrations either generate or pick up and propagate the trace header automatically, as appropriate, for all transactions and spans that they generate. diff --git a/src/platform-includes/distributed-tracing/index/javascript.mdx b/src/platform-includes/distributed-tracing/index/javascript.mdx new file mode 100644 index 0000000000000..eefc93ca7e398 --- /dev/null +++ b/src/platform-includes/distributed-tracing/index/javascript.mdx @@ -0,0 +1,77 @@ +## Navigation and Other XHR Requests + +For traces that begin in the front end, any requests made (and any requests your backend makes as a result) are linked through the request headers `sentry-trace` and `baggage`. The `sentry-trace` header holds information for identifying the trace, while the [W3C compliant](https://www.w3.org/TR/baggage/) `baggage` header contains additional trace-related data that is used for trace-based sampling. + + + +The `baggage` header was added with version 7 of the Sentry Javascript SDK and is not yet standardized across other Sentry SDKs. It is part of an ongoing effort to create a more frictionless and targeted sampling approach, and its content is subject to change. + + + +All of Sentry's tracing-related integrations (`BrowserTracing`, `Http`, and `Express`), as well as the Next.JS SDK, either generate or pick up and propagate the trace headers automatically, as appropriate, for all transactions and spans that they generate. + +The JavaScript SDK will only attach the trace headers to outgoing HTTP requests for which the destination is a substring or regex match to the tracePropagationTargets list. `tracePropagationTargets` was previously called `tracingOrigins`. + + + +You'll need to configure your web server [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers) to allow the `sentry-trace` and `baggage` headers. The configuration might look like `"Access-Control-Allow-Headers: sentry-trace"` and `"Access-Control-Allow-Headers: baggage"`, but the configuration depends on your setup. If you don't allow the `sentry-trace` and `baggage` headers, the request might be blocked. + +## Pageload + + + +For traces that begin in your backend, you can connect the automatically-generated `pageload` transaction on the frontend with the request transaction that serves the page on the backend. Because JavaScript code running in a browser cannot read the response headers of the current page, the trace data must be transmitted in the response itself, specifically in `` tags in the `` of the HTML sent from your backend. + +```html + + + + + + + +``` + + + +Remix SDK attaches `sentry-trace` and `baggage` values from your `root` loader. You need to use [`meta`](https://remix.run/docs/en/v1/api/conventions#meta) function to attach the data from your `loader` as `` tags. The following code snippet shows how to do this: + +```typescript {filename: root.tsx} +export const meta: MetaFunction = ({ data }) => { + return { + // ... + "sentry-trace": data.sentryTrace, + baggage: data.sentryBaggage, + }; +}; +``` + + + +This feature is available on Sentry Remix SDK version 7.9.0 and above. + + + + + +The `name` attributes must be the strings `"sentry-trace"` and `"baggage"` and the `content` attributes must be generated by your backend Sentry SDK. For `sentry-trace`, use `span.toSentryTrace()` (or equivalent, depending on the backend platform). This guarantees that a new and unique value will be generated for each request. For `baggage`, use `serializeBaggage(span.getBaggage())`. + + + +The `span.toSentryTrace()` was previously called `span.toTraceparent()`, so that's what you may find depending on the SDK and version. + + + +The `span` reference is either the transaction that serves the HTML or any of its child spans. It defines the parent of the `pageload` transaction. + +Once the data is included in the `` tags, our `BrowserTracing` integration will pick them up automatically and link them to the transaction generated on pageload. Note that they will not be linked to automatically-generated `navigation` transactions — that is, those that don't require a full page reload. Each of those will be the result of a different request transaction on the backend and, therefore, should have a unique `trace_id`. + + + + + +For traces that begin in your backend, the `@sentry/nextjs` SDK will automatically connect pageload navigations in the frontend with the request transaction that serves the page on the backend. + +The SDK will return additional props from your configured [Next.js data fetchers](https://nextjs.org/docs/basic-features/data-fetching/overview) that the SDK picks up in to browser to connect the pageload transaction with the backend request. + + diff --git a/src/platform-includes/distributed-tracing/index/node.mdx b/src/platform-includes/distributed-tracing/index/node.mdx new file mode 100644 index 0000000000000..9f2b8c120f6f6 --- /dev/null +++ b/src/platform-includes/distributed-tracing/index/node.mdx @@ -0,0 +1,27 @@ +## Distributed Tracing + +To obtain a trace from a span, use `toTraceParent()` method. This method returns a string that can be used as a value of the `traceparent` HTTP header: + +```javascript +const sentryTraceHeader = span.toTraceparent(); + +requestOptions.headers = { + ...requestOptions.headers, + "sentry-trace": sentryTraceHeader, +}; +``` + +To create a span as a continuation of the trace retrieved from the upstream service, use `extractTraceparentData` function from `@sentry/node`: + +```javascript +import { extractTraceparentData } from "@sentry/node"; + +// The request headers sent by your upstream service to your backend. +const traceparentData = extractTraceparentData(request.headers["sentry-trace"]); + +const transaction = Sentry.startTransaction({ + op: "transaction_op", + name: "transaction_name", + ...traceparentData, +}); +``` diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/dart.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/dart.mdx new file mode 100644 index 0000000000000..a86529c2e4d3c --- /dev/null +++ b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/dart.mdx @@ -0,0 +1,21 @@ +To obtain a trace header from the span, use `ISentrySpan#toSentryTrace()` method. Then pass it to the downstream service. If the communication happens over HTTP, it is recommended that you set the value to the `sentry-trace` HTTP header. + +To create a span as a continuation of the trace retrieved from the upstream service, pass the `sentry-trace` header value to the transaction context: + +```dart +import 'package:sentry/sentry.dart'; + +final header = request.headers['sentry-trace']; +final sentryTraceHeader = SentryTraceHeader.fromTraceHeader(header); +try { + final transaction = Sentry.startTransactionWithContext(SentryTransactionContext.fromSentryTrace('name', 'operation', sentryTraceHeader)); +} catch (error) { + // handle [InvalidSentryTraceHeaderException] if invalid `sentry-trace` header. +} +``` + + + +The `SentryHttpClient` instrumentation handles trace continuations automatically when enabling the [performance](/platforms/dart/performance/) feature. + + diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/dotnet.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/dotnet.mdx new file mode 100644 index 0000000000000..83d35b0c25e15 --- /dev/null +++ b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/dotnet.mdx @@ -0,0 +1,51 @@ +To obtain a trace header from the span, use `ISpan.GetTraceHeader()` method, then pass it to the downstream service. + + + +For HTTP communications, Sentry's SDK provides `SentryHttpMessageHandler`, which can be used to [automatically attach trace headers to outgoing HTTP requests](/platforms/dotnet/performance/instrumentation/automatic-instrumentation/). + + + +The code snippet below demonstrates propagating the trace programatically. Even though `SentryHttpMessageHandler` does that automatically for you, this illustrates the mechanism so it can be replicated in other protocols and technologies such a messaging systems. + +```csharp +using System; +using System.Net.Http; +using Sentry; + +var transaction = SentrySdk.StartTransaction("name", "op"); +var sentryTraceHeader = transaction.GetTraceHeader(); + +using var request = new HttpRequestMessage(HttpMethod.Get, "https://example.com"); +request.Headers.Add("sentry-trace", sentryTraceHeader.ToString()); +``` + +To create a span as a continuation of the trace retrieved from the upstream service, pass the `sentry-trace` header value to the `StartTransaction(...)` method: + +```csharp +using System; +using Sentry; + +var httpContext = ...; + +if (httpContext.Request.Headers.TryGetValue("sentry-trace", out var sentryTraceHeaderValue)) +{ + try + { + var sentryTraceHeader = SentryTraceHeader.Parse(sentryTraceHeaderValue); + var transaction = SentrySdk.StartTransaction("name", "op", sentryTraceHeader); + } + catch (FormatException e) + { + // Handle invalid trace header + e.Data["bad-sentry-header"] = sentryTraceHeaderValue; + SentrySdk.CaptureException(e); + } +} +``` + + + +In Sentry's ASP.NET Core integration, trace headers are [handled automatically by the tracing middleware](/platforms/dotnet/performance/instrumentation/automatic-instrumentation/). + + diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/java.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/java.mdx new file mode 100644 index 0000000000000..d7fa45dc37484 --- /dev/null +++ b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/java.mdx @@ -0,0 +1,62 @@ +To obtain a trace header from the span, use `ISpan#toSentryTrace()` method. Then pass it to the downstream service. If the communication happens over HTTP, it's recommended that you set the value to the `sentry-trace` (also available as a constant `SentryTraceHeader.SENTRY_TRACE_HEADER`) HTTP header, as well as attaching the `baggage` header (`BaggageHeader.BAGGAGE_HEADER`) which can be retrieved from `ISpan#toBaggageHeader(List)`. You should also pass in any existing `baggage` header entries that are present on the outgoing request so we can handle duplicate Sentry entries and limits for you. + +To create a span as a continuation of the trace retrieved from the upstream service, pass the `sentry-trace` and `baggage` header values to the transaction context: + +```java +import io.sentry.Baggage; +import io.sentry.BaggageHeader; +import io.sentry.ITransaction; +import io.sentry.Sentry; +import io.sentry.SentryTraceHeader; +import io.sentry.TransactionContext; +import io.sentry.exception.InvalidSentryTraceHeaderException; + +String sentryTrace = request.getHeader(SentryTraceHeader.SENTRY_TRACE_HEADER); +List baggageHeaders = Collections.list(request.getHeaders(BaggageHeader.BAGGAGE_HEADER); +ITransaction transaction = null; +try { + transaction = Sentry.startTransaction( + TransactionContext.fromSentryTrace( + "name", + TransactionNameSource.CUSTOM, + "op", + new SentryTraceHeader(sentryTrace), + Baggage.fromHeader(baggageHeaders) + ) + ); +} catch (InvalidSentryTraceHeaderException e) { + // handle invalid trace header +} +``` + +```kotlin +import io.sentry.Baggage; +import io.sentry.BaggageHeader; +import io.sentry.ITransaction; +import io.sentry.Sentry; +import io.sentry.SentryTraceHeader; +import io.sentry.TransactionContext; +import io.sentry.exception.InvalidSentryTraceHeaderException; + +val sentryTrace = request.getHeader(SentryTraceHeader.SENTRY_TRACE_HEADER) +val baggageHeaders = request.getHeaders(BaggageHeader.BAGGAGE_HEADER) +val transaction = try { + Sentry.startTransaction( + TransactionContext.fromSentryTrace( + "name", + TransactionNameSource.CUSTOM, + "op", + SentryTraceHeader(sentryTrace), + Baggage.fromHeader(baggageHeaders) + ) + ) +} catch (e: InvalidSentryTraceHeaderException) { + // handle invalid trace header +} +``` + + + +In Spring and Spring Boot integrations, Spring MVC, `RestTemplate` and OkHttp instrumentation handles trace continuations automatically. + + diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/native.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/native.mdx new file mode 100644 index 0000000000000..2e69daf7bee0c --- /dev/null +++ b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/native.mdx @@ -0,0 +1,43 @@ +To obtain trace headers from a transaction, use `sentry_transaction_iter_headers()`. For a span, use `sentry_span_iter_headers()`.Pass the returned value to the downstream service. If communication happens over HTTP, we recommend you attach all headers to the outgoing HTTP request. + +Continuing a trace from an upstream service requires using `sentry_transaction_context_update_from_header()`. Before starting a transaction, pass its transaction context into the previous function along with the `sentry-trace` header. The transaction started with the transaction context will contain everything needed to continue the trace. + +To obtain headers from a transaction so it can be continued from a downstream service, define a function which merges the headers into some aggregate object. Use the function in `sentry_transaction_iter_headers()` as a callback. The following example uses `sentry_value_t` as the aggregate object: + +```c +static void +copy_headers_to(const char *key, const char *value, void *userdata) +{ + sentry_value_t *headers + = (sentry_value_t *)userdata; + sentry_value_set_by_key(*headers, key, value); +} + +int main(int argc, char **argv) { + ... + // Transaction to continue off of + sentry_transaction_context_t *tx_ctx = sentry_transaction_context_new( + "honk", + NULL, + ); + sentry_transaction_t *tx = sentry_transaction_start(tx_ctx, sentry_value_new_null()); + + sentry_value_t *headers = sentry_value_new_object(); + sentry_transaction_iter_headers(tx, copy_headers_to, (void *)headers); +} +``` + +To create a transaction as a continuation of a trace retrieved from an upstream service, pass an iterator of the incoming headers to the transaction context: + +```c + sentry_transaction_context_t *tx_ctx = sentry_transaction_context_new( + "honk", + NULL, + ); + sentry_transaction_context_update_from_header( + tx_ctx, + "sentry-trace", + "atraceid-aspanid-issampled", + ); + +``` diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/rust.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/rust.mdx new file mode 100644 index 0000000000000..27a8784bd00dd --- /dev/null +++ b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/rust.mdx @@ -0,0 +1,35 @@ +To obtain trace headers from a span, use the `iter_headers()` method. Then pass these to the downstream service. If the communication happens over HTTP, it is recommended to attach all headers to the outgoing HTTP request. + +For example when using the `reqwest` crate: + +```rust +let client = reqwest::Client::new(); + +let mut request = client.get("downstream-url"); +if let Some(span) = sentry::configure_scope(|scope| scope.get_span()) { + for (k, v) in span.iter_headers() { + request = request.header(k, v); + } +} + +let response = request.send().await?; +``` + +To create a span as a continuation of the trace retrieved from the upstream service, pass an iterator of the incoming headers to the transaction context: + +```rust +// This needs to be a `impl Iterator` of header key/value pairs. +let headers = request.headers(); +let tx_ctx = sentry::TransactionContext::continue_from_headers( + "transaction name", + "http.server", + headers, +); +let transaction = sentry::start_transaction(tx_ctx); +``` + + + +For usage with the `tower` crate, the `SentryHttpLayer` handles trace continuations automatically when constructed via `SentryHttpLayer::with_transaction()`. + + diff --git a/src/platforms/common/distributed-tracing/index.mdx b/src/platforms/common/distributed-tracing/index.mdx index 51af840b6c693..201dc1c996502 100644 --- a/src/platforms/common/distributed-tracing/index.mdx +++ b/src/platforms/common/distributed-tracing/index.mdx @@ -2,13 +2,30 @@ title: Distributed Tracing sidebar_order: 40 description: "Learn how to connect backend and frontend transactions." -supported: - - java - - javascript - - php - - python --- +When tracing is enabled, the SDK will attach an outgoing header called `sentry-trace` to requests. This depends on the out of the box integrations we provide, but you can expect the header `sentry-trace` to be present. If it's not, you can manually add `sentry-trace` headers to any requests by learning more about [its structure](https://develop.sentry.dev/sdk/performance/#header-sentry-trace). + +SDKs with performance monitoring support listen to incoming requests and typically automatically pick up the incoming `sentry-trace` header to continue the trace (with the same `trace-id`) from there, connecting backend and frontend transactions into a single coherent trace using the `trace_id` value. Depending on the circumstance, this ID is transmitted either in a request header or in an HTML `` tag. + +All your transactions that have the same `trace-id` are connected. Linking transactions in this way makes it possible to navigate among them in [sentry.io](https://sentry.io) to better understand how the different parts of your system are affecting one another. You can learn more about this model in our [Distributed Tracing](/product/sentry-basics/tracing/distributed-tracing/) docs. + + + +If the instrumentation you're using doesn't automatically pick up the `sentry-trace` header, you can also continue a trace manually by using the `continueFromHeaders` function on a `Transaction`. Learn more about this in our [Transaction Interface](https://develop.sentry.dev/sdk/performance/#new-span-and-transaction-classes) documentation. + + + + + + + + + + + +# Temp + Was ist dt und warum ist es cool? -> vielleicht etwas von der Produktseite übernehmen diff --git a/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx b/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx index 9d0cd926f6741..fc08761835f6c 100644 --- a/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx +++ b/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx @@ -16,3 +16,15 @@ distributed tracing funktioniert ohne weiter config sucht in HTTP Headern und in Environment Variablen -> page ausblenden wenn nicht supported + + + + + +## Distributed Tracing + +Traces can bridge across multiple software services. Each span in a trace can be represented as a `sentry-trace` header, containing the trace id, span id, and sampling details. This `sentry-trace` header can be passed to downstream services so that they can create spans that are a continuation of the trace started in the originating service. + + + + diff --git a/src/platforms/common/performance/distributed-tracing.mdx b/src/platforms/common/performance/distributed-tracing.mdx deleted file mode 100644 index f0cc104c03af5..0000000000000 --- a/src/platforms/common/performance/distributed-tracing.mdx +++ /dev/null @@ -1,25 +0,0 @@ ---- -title: Distributed Tracing -sidebar_order: 40 -description: "Learn how to connect backend and frontend transactions." -notSupported: - - php ---- - -When tracing is enabled, the SDK will attach an outgoing header called `sentry-trace` to requests. This depends on the out of the box integrations we provide, but you can expect the header `sentry-trace` to be present. If it's not, you can manually add `sentry-trace` headers to any requests by learning more about [its structure](https://develop.sentry.dev/sdk/performance/#header-sentry-trace). - -SDKs with performance monitoring support listen to incoming requests and typically automatically pick up the incoming `sentry-trace` header to continue the trace (with the same `trace-id`) from there, connecting backend and frontend transactions into a single coherent trace using the `trace_id` value. Depending on the circumstance, this ID is transmitted either in a request header or in an HTML `` tag. - -All your transactions that have the same `trace-id` are connected. Linking transactions in this way makes it possible to navigate among them in [sentry.io](https://sentry.io) to better understand how the different parts of your system are affecting one another. You can learn more about this model in our [Distributed Tracing](/product/sentry-basics/tracing/distributed-tracing/) docs. - - - -If the instrumentation you're using doesn't automatically pick up the `sentry-trace` header, you can also continue a trace manually by using the `continueFromHeaders` function on a `Transaction`. Learn more about this in our [Transaction Interface](https://develop.sentry.dev/sdk/performance/#new-span-and-transaction-classes) documentation. - - - - - - - - diff --git a/src/platforms/common/performance/instrumentation/custom-instrumentation.mdx b/src/platforms/common/performance/instrumentation/custom-instrumentation.mdx index 7a1c6c42564a4..335f78d6b0c46 100644 --- a/src/platforms/common/performance/instrumentation/custom-instrumentation.mdx +++ b/src/platforms/common/performance/instrumentation/custom-instrumentation.mdx @@ -76,13 +76,3 @@ To instrument certain regions of your code, you can create transactions to captu - - - -## Distributed Tracing - -Traces can bridge across multiple software services. Each span in a trace can be represented as a `sentry-trace` header, containing the trace id, span id, and sampling details. This `sentry-trace` header can be passed to downstream services so that they can create spans that are a continuation of the trace started in the originating service. - - - - From a91e1ecd84f542a0654809545515f853cde19310 Mon Sep 17 00:00:00 2001 From: "getsantry[bot]" <66042841+getsantry[bot]@users.noreply.github.com> Date: Thu, 15 Jun 2023 14:04:27 +0000 Subject: [PATCH 022/116] style(lint): Auto commit lint changes --- src/platforms/common/distributed-tracing/index.mdx | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/platforms/common/distributed-tracing/index.mdx b/src/platforms/common/distributed-tracing/index.mdx index 201dc1c996502..a6bcd4f527ab5 100644 --- a/src/platforms/common/distributed-tracing/index.mdx +++ b/src/platforms/common/distributed-tracing/index.mdx @@ -22,8 +22,6 @@ If the instrumentation you're using doesn't automatically pick up the `sentry-tr - - # Temp Was ist dt und warum ist es cool? From 7893578d20cae6fed6ea48f7fc1e7a5a6418044e Mon Sep 17 00:00:00 2001 From: "getsantry[bot]" <66042841+getsantry[bot]@users.noreply.github.com> Date: Thu, 15 Jun 2023 14:04:27 +0000 Subject: [PATCH 023/116] style(lint): Auto commit lint changes --- .../instrumentation/automatic-instrumentation.mdx | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx b/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx index fc08761835f6c..5f28c3f07b173 100644 --- a/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx +++ b/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx @@ -17,8 +17,6 @@ sucht in HTTP Headern und in Environment Variablen -> page ausblenden wenn nicht supported - - ## Distributed Tracing From 891ff367f4edaa2d9c93bdc2614a087c14b32dc1 Mon Sep 17 00:00:00 2001 From: Stephanie Anderson Date: Mon, 19 Jun 2023 08:29:05 +0200 Subject: [PATCH 024/116] move python content into platform include files --- .../distributed-tracing/index/_default.mdx | 3 + .../distributed-tracing/index/android.mdx | 7 -- .../distributed-tracing/index/javascript.mdx | 77 ------------------- .../distributed-tracing/index/node.mdx | 27 ------- .../distributed-tracing/index/python.mdx | 8 ++ .../automatic-instrumentation/_default.mdx | 15 ++++ .../automatic-instrumentation/php.mdx | 5 ++ .../python.django.mdx} | 12 ++- .../automatic-instrumentation/python.mdx | 60 +++++++++++++++ .../custom-instrumentation/_default.mdx | 5 ++ .../custom-instrumentation/dart.mdx | 21 ----- .../custom-instrumentation/dotnet.mdx | 51 ------------ .../custom-instrumentation/java.mdx | 62 --------------- .../custom-instrumentation/native.mdx | 43 ----------- .../custom-instrumentation/php.mdx | 5 ++ .../custom-instrumentation/python.mdx | 5 ++ .../custom-instrumentation/rust.mdx | 35 --------- .../automatic-instrumentation.mdx | 19 +---- .../custom-instrumentation.mdx | 55 +------------ .../instrumentation/index.mdx | 5 +- 20 files changed, 114 insertions(+), 406 deletions(-) create mode 100644 src/platform-includes/distributed-tracing/index/_default.mdx delete mode 100644 src/platform-includes/distributed-tracing/index/android.mdx delete mode 100644 src/platform-includes/distributed-tracing/index/javascript.mdx delete mode 100644 src/platform-includes/distributed-tracing/index/node.mdx create mode 100644 src/platform-includes/distributed-tracing/index/python.mdx create mode 100644 src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/_default.mdx create mode 100644 src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/php.mdx rename src/{platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation.mdx => platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.django.mdx} (90%) create mode 100644 src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.mdx create mode 100644 src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/_default.mdx delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/dart.mdx delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/dotnet.mdx delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/java.mdx delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/native.mdx create mode 100644 src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/php.mdx create mode 100644 src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/rust.mdx diff --git a/src/platform-includes/distributed-tracing/index/_default.mdx b/src/platform-includes/distributed-tracing/index/_default.mdx new file mode 100644 index 0000000000000..52149488f81c7 --- /dev/null +++ b/src/platform-includes/distributed-tracing/index/_default.mdx @@ -0,0 +1,3 @@ + +Please refer to tracing with and without performance activated and delete this note and its headline afterwards. + diff --git a/src/platform-includes/distributed-tracing/index/android.mdx b/src/platform-includes/distributed-tracing/index/android.mdx deleted file mode 100644 index f57c51595d46a..0000000000000 --- a/src/platform-includes/distributed-tracing/index/android.mdx +++ /dev/null @@ -1,7 +0,0 @@ -### HTTP and GraphQL Requests - -For traces that begin in the mobile app, any requests made (and any requests your backend makes as a result) are linked through the request header `sentry-trace`. - -The Sentry Android SDK offers [OkHttp](/platforms/android/configuration/integrations/okhttp/) and [Apollo](/platforms/android/configuration/integrations/apollo/) integrations for HTTP and GraphQL requests respectively. - -These integrations either generate or pick up and propagate the trace header automatically, as appropriate, for all transactions and spans that they generate. diff --git a/src/platform-includes/distributed-tracing/index/javascript.mdx b/src/platform-includes/distributed-tracing/index/javascript.mdx deleted file mode 100644 index eefc93ca7e398..0000000000000 --- a/src/platform-includes/distributed-tracing/index/javascript.mdx +++ /dev/null @@ -1,77 +0,0 @@ -## Navigation and Other XHR Requests - -For traces that begin in the front end, any requests made (and any requests your backend makes as a result) are linked through the request headers `sentry-trace` and `baggage`. The `sentry-trace` header holds information for identifying the trace, while the [W3C compliant](https://www.w3.org/TR/baggage/) `baggage` header contains additional trace-related data that is used for trace-based sampling. - - - -The `baggage` header was added with version 7 of the Sentry Javascript SDK and is not yet standardized across other Sentry SDKs. It is part of an ongoing effort to create a more frictionless and targeted sampling approach, and its content is subject to change. - - - -All of Sentry's tracing-related integrations (`BrowserTracing`, `Http`, and `Express`), as well as the Next.JS SDK, either generate or pick up and propagate the trace headers automatically, as appropriate, for all transactions and spans that they generate. - -The JavaScript SDK will only attach the trace headers to outgoing HTTP requests for which the destination is a substring or regex match to the tracePropagationTargets list. `tracePropagationTargets` was previously called `tracingOrigins`. - - - -You'll need to configure your web server [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers) to allow the `sentry-trace` and `baggage` headers. The configuration might look like `"Access-Control-Allow-Headers: sentry-trace"` and `"Access-Control-Allow-Headers: baggage"`, but the configuration depends on your setup. If you don't allow the `sentry-trace` and `baggage` headers, the request might be blocked. - -## Pageload - - - -For traces that begin in your backend, you can connect the automatically-generated `pageload` transaction on the frontend with the request transaction that serves the page on the backend. Because JavaScript code running in a browser cannot read the response headers of the current page, the trace data must be transmitted in the response itself, specifically in `` tags in the `` of the HTML sent from your backend. - -```html - - - - - - - -``` - - - -Remix SDK attaches `sentry-trace` and `baggage` values from your `root` loader. You need to use [`meta`](https://remix.run/docs/en/v1/api/conventions#meta) function to attach the data from your `loader` as `` tags. The following code snippet shows how to do this: - -```typescript {filename: root.tsx} -export const meta: MetaFunction = ({ data }) => { - return { - // ... - "sentry-trace": data.sentryTrace, - baggage: data.sentryBaggage, - }; -}; -``` - - - -This feature is available on Sentry Remix SDK version 7.9.0 and above. - - - - - -The `name` attributes must be the strings `"sentry-trace"` and `"baggage"` and the `content` attributes must be generated by your backend Sentry SDK. For `sentry-trace`, use `span.toSentryTrace()` (or equivalent, depending on the backend platform). This guarantees that a new and unique value will be generated for each request. For `baggage`, use `serializeBaggage(span.getBaggage())`. - - - -The `span.toSentryTrace()` was previously called `span.toTraceparent()`, so that's what you may find depending on the SDK and version. - - - -The `span` reference is either the transaction that serves the HTML or any of its child spans. It defines the parent of the `pageload` transaction. - -Once the data is included in the `` tags, our `BrowserTracing` integration will pick them up automatically and link them to the transaction generated on pageload. Note that they will not be linked to automatically-generated `navigation` transactions — that is, those that don't require a full page reload. Each of those will be the result of a different request transaction on the backend and, therefore, should have a unique `trace_id`. - - - - - -For traces that begin in your backend, the `@sentry/nextjs` SDK will automatically connect pageload navigations in the frontend with the request transaction that serves the page on the backend. - -The SDK will return additional props from your configured [Next.js data fetchers](https://nextjs.org/docs/basic-features/data-fetching/overview) that the SDK picks up in to browser to connect the pageload transaction with the backend request. - - diff --git a/src/platform-includes/distributed-tracing/index/node.mdx b/src/platform-includes/distributed-tracing/index/node.mdx deleted file mode 100644 index 9f2b8c120f6f6..0000000000000 --- a/src/platform-includes/distributed-tracing/index/node.mdx +++ /dev/null @@ -1,27 +0,0 @@ -## Distributed Tracing - -To obtain a trace from a span, use `toTraceParent()` method. This method returns a string that can be used as a value of the `traceparent` HTTP header: - -```javascript -const sentryTraceHeader = span.toTraceparent(); - -requestOptions.headers = { - ...requestOptions.headers, - "sentry-trace": sentryTraceHeader, -}; -``` - -To create a span as a continuation of the trace retrieved from the upstream service, use `extractTraceparentData` function from `@sentry/node`: - -```javascript -import { extractTraceparentData } from "@sentry/node"; - -// The request headers sent by your upstream service to your backend. -const traceparentData = extractTraceparentData(request.headers["sentry-trace"]); - -const transaction = Sentry.startTransaction({ - op: "transaction_op", - name: "transaction_name", - ...traceparentData, -}); -``` diff --git a/src/platform-includes/distributed-tracing/index/python.mdx b/src/platform-includes/distributed-tracing/index/python.mdx new file mode 100644 index 0000000000000..2bfd0e0ac48cc --- /dev/null +++ b/src/platform-includes/distributed-tracing/index/python.mdx @@ -0,0 +1,8 @@ + +Please refer to tracing with and without performance activated and delete this note and its headline afterwards. + + + +Distributed tracing works out of the box for the following frameworks: [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/), [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/),[Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/), [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/), [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/), [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/), [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlite](/platforms/python/guides/starlite/distributed-tracing/instrumentation/automatic-instrumentation/), [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/). + +If you have a vanilla Python project or use a (yet) unsupported framework you need to implement Custom Instrumentation. diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/_default.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/_default.mdx new file mode 100644 index 0000000000000..f640c9bea086f --- /dev/null +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/_default.mdx @@ -0,0 +1,15 @@ +# AUTOMATIC DEFAULT + + +Please refer to tracing with and without performance activated and delete this note and its headline afterwards. + + + +# OTHER NOTES +Automatic instrumentation is supported for the following frameworks: + +distributed tracing funktioniert ohne weiter config + +sucht in HTTP Headern und in Environment Variablen + +-> page ausblenden wenn nicht supported diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/php.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/php.mdx new file mode 100644 index 0000000000000..81e8a8b514a4d --- /dev/null +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/php.mdx @@ -0,0 +1,5 @@ +# AUTOMATIC PHP + + +Please refer to tracing with and without performance activated and delete this note and its headline afterwards. + diff --git a/src/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.django.mdx similarity index 90% rename from src/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation.mdx rename to src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.django.mdx index c3ad422295c1a..4329a1ee2f8c9 100644 --- a/src/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.django.mdx @@ -1,10 +1,8 @@ ---- -title: Automatic Instrumentation -sidebar_order: 40 -description: "" -supported: - - python.django ---- +# AUTOMATIC PYTHON DJANGO + + +Please refer to tracing with and without performance activated and delete this note and its headline afterwards. + If you run a Django project distributed tracing works out of the box. If requests to your Django project include the `sentry-trace` and `baggage` headers they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.mdx new file mode 100644 index 0000000000000..a6a047768a9aa --- /dev/null +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.mdx @@ -0,0 +1,60 @@ +# AUTOMATIC PYTHON + + +Please refer to tracing with and without performance activated and delete this note and its headline afterwards. + + + +Distributed tracing works out of the box for the following frameworks: [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/), [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/),[Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/), [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/), [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/), [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/), [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlite](/platforms/python/guides/starlite/distributed-tracing/instrumentation/automatic-instrumentation/), [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/). + +If you are using one of the frameworks listed above, you do not need to do anything for distributed tracing to work! You can now stop reading this page and continue building and amazing product. + +If you have a vanilla Python project or use a (yet) unsupported framework you can still add distributed tracing to your project but need to it "by hand". + +Two things need to be done for distributed tracing to work: + +- When receiving incoming requests, parse and store incoming tracing information. +- When doing outgoing requests, add tracing information to the outgoing request. + +## Parse incoming tracing information + +Incoming tracing information has to be parsed and saved. +Incoming tracing can come from different places: + +- In a web environment it will be sent with HTTP headers. +- In a job queue (like Celery) the tracing information can be retrieved from some meta or header variables. +- You also can pick up tracing information from environment variables. + +```python +import sentry_sdk +from my_project import get_incoming_headers_as_dict + +headers = get_incoming_headers_as_dict() + +sentry_sdk.continue_trace(headers) +``` + +This will parse the given headers and try to find the `sentry-trace` and `baggage` headers and it will store them for later use. + +## Add tracing information to outgoing requests + +On outgoing requests to have to add the two headers `sentry-trace` and `baggage` that you parsed and stored earlier. + +If you are doing your HTTP requests with [Requests](https://requests.readthedocs.io/en/latest/), [AIOHTTP](https://docs.aiohttp.org/en/stable/), the low level [http.client](https://docs.python.org/3/library/http.client.html), or [httplib](https://docs.python.org/2/library/httplib.html) on Pyton 2 the parsed and stored headers are added automatically to outgoing requests. You do not need to do anything! + +If you do outgoing requests in another way you can prepare the headers like follows: + +```python +import sentry_sdk +from my_project import make_an_outgoing_request + +headers = {} +headers["sentry-trace"] = sentry_sdk.get_traceparent() +headers["baggage"] = sentry_sdk.get_baggage() + +make_an_outgoing_request(to="https://example.com", headers=headers) +``` + +Now tracing information is propagated to the project running at `https://example.com`. If it has the Python SDK with distributed tracing running, it will parse and save the tracing information for later use. + +The two services are now connect with distributed tracing. diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/_default.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/_default.mdx new file mode 100644 index 0000000000000..37ff85d56ca69 --- /dev/null +++ b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/_default.mdx @@ -0,0 +1,5 @@ +# CUSTOM DEFAULT + + +Please refer to tracing with and without performance activated and delete this note and its headline afterwards. + diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/dart.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/dart.mdx deleted file mode 100644 index a86529c2e4d3c..0000000000000 --- a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/dart.mdx +++ /dev/null @@ -1,21 +0,0 @@ -To obtain a trace header from the span, use `ISentrySpan#toSentryTrace()` method. Then pass it to the downstream service. If the communication happens over HTTP, it is recommended that you set the value to the `sentry-trace` HTTP header. - -To create a span as a continuation of the trace retrieved from the upstream service, pass the `sentry-trace` header value to the transaction context: - -```dart -import 'package:sentry/sentry.dart'; - -final header = request.headers['sentry-trace']; -final sentryTraceHeader = SentryTraceHeader.fromTraceHeader(header); -try { - final transaction = Sentry.startTransactionWithContext(SentryTransactionContext.fromSentryTrace('name', 'operation', sentryTraceHeader)); -} catch (error) { - // handle [InvalidSentryTraceHeaderException] if invalid `sentry-trace` header. -} -``` - - - -The `SentryHttpClient` instrumentation handles trace continuations automatically when enabling the [performance](/platforms/dart/performance/) feature. - - diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/dotnet.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/dotnet.mdx deleted file mode 100644 index 83d35b0c25e15..0000000000000 --- a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/dotnet.mdx +++ /dev/null @@ -1,51 +0,0 @@ -To obtain a trace header from the span, use `ISpan.GetTraceHeader()` method, then pass it to the downstream service. - - - -For HTTP communications, Sentry's SDK provides `SentryHttpMessageHandler`, which can be used to [automatically attach trace headers to outgoing HTTP requests](/platforms/dotnet/performance/instrumentation/automatic-instrumentation/). - - - -The code snippet below demonstrates propagating the trace programatically. Even though `SentryHttpMessageHandler` does that automatically for you, this illustrates the mechanism so it can be replicated in other protocols and technologies such a messaging systems. - -```csharp -using System; -using System.Net.Http; -using Sentry; - -var transaction = SentrySdk.StartTransaction("name", "op"); -var sentryTraceHeader = transaction.GetTraceHeader(); - -using var request = new HttpRequestMessage(HttpMethod.Get, "https://example.com"); -request.Headers.Add("sentry-trace", sentryTraceHeader.ToString()); -``` - -To create a span as a continuation of the trace retrieved from the upstream service, pass the `sentry-trace` header value to the `StartTransaction(...)` method: - -```csharp -using System; -using Sentry; - -var httpContext = ...; - -if (httpContext.Request.Headers.TryGetValue("sentry-trace", out var sentryTraceHeaderValue)) -{ - try - { - var sentryTraceHeader = SentryTraceHeader.Parse(sentryTraceHeaderValue); - var transaction = SentrySdk.StartTransaction("name", "op", sentryTraceHeader); - } - catch (FormatException e) - { - // Handle invalid trace header - e.Data["bad-sentry-header"] = sentryTraceHeaderValue; - SentrySdk.CaptureException(e); - } -} -``` - - - -In Sentry's ASP.NET Core integration, trace headers are [handled automatically by the tracing middleware](/platforms/dotnet/performance/instrumentation/automatic-instrumentation/). - - diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/java.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/java.mdx deleted file mode 100644 index d7fa45dc37484..0000000000000 --- a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/java.mdx +++ /dev/null @@ -1,62 +0,0 @@ -To obtain a trace header from the span, use `ISpan#toSentryTrace()` method. Then pass it to the downstream service. If the communication happens over HTTP, it's recommended that you set the value to the `sentry-trace` (also available as a constant `SentryTraceHeader.SENTRY_TRACE_HEADER`) HTTP header, as well as attaching the `baggage` header (`BaggageHeader.BAGGAGE_HEADER`) which can be retrieved from `ISpan#toBaggageHeader(List)`. You should also pass in any existing `baggage` header entries that are present on the outgoing request so we can handle duplicate Sentry entries and limits for you. - -To create a span as a continuation of the trace retrieved from the upstream service, pass the `sentry-trace` and `baggage` header values to the transaction context: - -```java -import io.sentry.Baggage; -import io.sentry.BaggageHeader; -import io.sentry.ITransaction; -import io.sentry.Sentry; -import io.sentry.SentryTraceHeader; -import io.sentry.TransactionContext; -import io.sentry.exception.InvalidSentryTraceHeaderException; - -String sentryTrace = request.getHeader(SentryTraceHeader.SENTRY_TRACE_HEADER); -List baggageHeaders = Collections.list(request.getHeaders(BaggageHeader.BAGGAGE_HEADER); -ITransaction transaction = null; -try { - transaction = Sentry.startTransaction( - TransactionContext.fromSentryTrace( - "name", - TransactionNameSource.CUSTOM, - "op", - new SentryTraceHeader(sentryTrace), - Baggage.fromHeader(baggageHeaders) - ) - ); -} catch (InvalidSentryTraceHeaderException e) { - // handle invalid trace header -} -``` - -```kotlin -import io.sentry.Baggage; -import io.sentry.BaggageHeader; -import io.sentry.ITransaction; -import io.sentry.Sentry; -import io.sentry.SentryTraceHeader; -import io.sentry.TransactionContext; -import io.sentry.exception.InvalidSentryTraceHeaderException; - -val sentryTrace = request.getHeader(SentryTraceHeader.SENTRY_TRACE_HEADER) -val baggageHeaders = request.getHeaders(BaggageHeader.BAGGAGE_HEADER) -val transaction = try { - Sentry.startTransaction( - TransactionContext.fromSentryTrace( - "name", - TransactionNameSource.CUSTOM, - "op", - SentryTraceHeader(sentryTrace), - Baggage.fromHeader(baggageHeaders) - ) - ) -} catch (e: InvalidSentryTraceHeaderException) { - // handle invalid trace header -} -``` - - - -In Spring and Spring Boot integrations, Spring MVC, `RestTemplate` and OkHttp instrumentation handles trace continuations automatically. - - diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/native.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/native.mdx deleted file mode 100644 index 2e69daf7bee0c..0000000000000 --- a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/native.mdx +++ /dev/null @@ -1,43 +0,0 @@ -To obtain trace headers from a transaction, use `sentry_transaction_iter_headers()`. For a span, use `sentry_span_iter_headers()`.Pass the returned value to the downstream service. If communication happens over HTTP, we recommend you attach all headers to the outgoing HTTP request. - -Continuing a trace from an upstream service requires using `sentry_transaction_context_update_from_header()`. Before starting a transaction, pass its transaction context into the previous function along with the `sentry-trace` header. The transaction started with the transaction context will contain everything needed to continue the trace. - -To obtain headers from a transaction so it can be continued from a downstream service, define a function which merges the headers into some aggregate object. Use the function in `sentry_transaction_iter_headers()` as a callback. The following example uses `sentry_value_t` as the aggregate object: - -```c -static void -copy_headers_to(const char *key, const char *value, void *userdata) -{ - sentry_value_t *headers - = (sentry_value_t *)userdata; - sentry_value_set_by_key(*headers, key, value); -} - -int main(int argc, char **argv) { - ... - // Transaction to continue off of - sentry_transaction_context_t *tx_ctx = sentry_transaction_context_new( - "honk", - NULL, - ); - sentry_transaction_t *tx = sentry_transaction_start(tx_ctx, sentry_value_new_null()); - - sentry_value_t *headers = sentry_value_new_object(); - sentry_transaction_iter_headers(tx, copy_headers_to, (void *)headers); -} -``` - -To create a transaction as a continuation of a trace retrieved from an upstream service, pass an iterator of the incoming headers to the transaction context: - -```c - sentry_transaction_context_t *tx_ctx = sentry_transaction_context_new( - "honk", - NULL, - ); - sentry_transaction_context_update_from_header( - tx_ctx, - "sentry-trace", - "atraceid-aspanid-issampled", - ); - -``` diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/php.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/php.mdx new file mode 100644 index 0000000000000..368a0a0a49c3f --- /dev/null +++ b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/php.mdx @@ -0,0 +1,5 @@ +# CUSTOM PHP + + +Please refer to tracing with and without performance activated and delete this note and its headline afterwards. + diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx new file mode 100644 index 0000000000000..a62f11bf697ea --- /dev/null +++ b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx @@ -0,0 +1,5 @@ +# CUSTOM PYTHON + + +Please refer to tracing with and without performance activated and delete this note and its headline afterwards. + diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/rust.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/rust.mdx deleted file mode 100644 index 27a8784bd00dd..0000000000000 --- a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/rust.mdx +++ /dev/null @@ -1,35 +0,0 @@ -To obtain trace headers from a span, use the `iter_headers()` method. Then pass these to the downstream service. If the communication happens over HTTP, it is recommended to attach all headers to the outgoing HTTP request. - -For example when using the `reqwest` crate: - -```rust -let client = reqwest::Client::new(); - -let mut request = client.get("downstream-url"); -if let Some(span) = sentry::configure_scope(|scope| scope.get_span()) { - for (k, v) in span.iter_headers() { - request = request.header(k, v); - } -} - -let response = request.send().await?; -``` - -To create a span as a continuation of the trace retrieved from the upstream service, pass an iterator of the incoming headers to the transaction context: - -```rust -// This needs to be a `impl Iterator` of header key/value pairs. -let headers = request.headers(); -let tx_ctx = sentry::TransactionContext::continue_from_headers( - "transaction name", - "http.server", - headers, -); -let transaction = sentry::start_transaction(tx_ctx); -``` - - - -For usage with the `tower` crate, the `SentryHttpLayer` handles trace continuations automatically when constructed via `SentryHttpLayer::with_transaction()`. - - diff --git a/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx b/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx index 5f28c3f07b173..5722dd776a581 100644 --- a/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx +++ b/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx @@ -4,25 +4,8 @@ sidebar_order: 40 description: "" supported: - java - - javascript - php - python --- -Automatic instrumentation is supported for the following frameworks: - -distributed tracing funktioniert ohne weiter config - -sucht in HTTP Headern und in Environment Variablen - --> page ausblenden wenn nicht supported - - - -## Distributed Tracing - -Traces can bridge across multiple software services. Each span in a trace can be represented as a `sentry-trace` header, containing the trace id, span id, and sampling details. This `sentry-trace` header can be passed to downstream services so that they can create spans that are a continuation of the trace started in the originating service. - - - - + diff --git a/src/platforms/common/distributed-tracing/instrumentation/custom-instrumentation.mdx b/src/platforms/common/distributed-tracing/instrumentation/custom-instrumentation.mdx index ea4234acf4dac..224e8b03d0fed 100644 --- a/src/platforms/common/distributed-tracing/instrumentation/custom-instrumentation.mdx +++ b/src/platforms/common/distributed-tracing/instrumentation/custom-instrumentation.mdx @@ -4,61 +4,8 @@ sidebar_order: 40 description: "" supported: - java - - javascript - php - python --- -Distributed tracing works out of the box for the following frameworks: [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/), [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/),[Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/), [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/), [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/), [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/), [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlite](/platforms/python/guides/starlite/distributed-tracing/instrumentation/automatic-instrumentation/), [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/). - -If you are using one of the frameworks listed above, you do not need to do anything for distributed tracing to work! You can now stop reading this page and continue building and amazing product. - -If you have a vanilla Python project or use a (yet) unsupported framework you can still add distributed tracing to your project but need to it "by hand". - -Two things need to be done for distributed tracing to work: - -- When receiving incoming requests, parse and store incoming tracing information. -- When doing outgoing requests, add tracing information to the outgoing request. - -## Parse incoming tracing information - -Incoming tracing information has to be parsed and saved. -Incoming tracing can come from different places: - -- In a web environment it will be sent with HTTP headers. -- In a job queue (like Celery) the tracing information can be retrieved from some meta or header variables. -- You also can pick up tracing information from environment variables. - -```python -import sentry_sdk -from my_project import get_incoming_headers_as_dict - -headers = get_incoming_headers_as_dict() - -sentry_sdk.continue_trace(headers) -``` - -This will parse the given headers and try to find the `sentry-trace` and `baggage` headers and it will store them for later use. - -## Add tracing information to outgoing requests - -On outgoing requests to have to add the two headers `sentry-trace` and `baggage` that you parsed and stored earlier. - -If you are doing your HTTP requests with [Requests](https://requests.readthedocs.io/en/latest/), [AIOHTTP](https://docs.aiohttp.org/en/stable/), the low level [http.client](https://docs.python.org/3/library/http.client.html), or [httplib](https://docs.python.org/2/library/httplib.html) on Pyton 2 the parsed and stored headers are added automatically to outgoing requests. You do not need to do anything! - -If you do outgoing requests in another way you can prepare the headers like follows: - -```python -import sentry_sdk -from my_project import make_an_outgoing_request - -headers = {} -headers["sentry-trace"] = sentry_sdk.get_traceparent() -headers["baggage"] = sentry_sdk.get_baggage() - -make_an_outgoing_request(to="https://example.com", headers=headers) -``` - -Now tracing information is propagated to the project running at `https://example.com`. If it has the Python SDK with distributed tracing running, it will parse and save the tracing information for later use. - -The two services are now connect with distributed tracing. + diff --git a/src/platforms/common/distributed-tracing/instrumentation/index.mdx b/src/platforms/common/distributed-tracing/instrumentation/index.mdx index 2d0dbe8b7c280..a8e1b8d84e147 100644 --- a/src/platforms/common/distributed-tracing/instrumentation/index.mdx +++ b/src/platforms/common/distributed-tracing/instrumentation/index.mdx @@ -4,11 +4,8 @@ sidebar_order: 40 description: "" supported: - java - - javascript - php - python --- -Distributed tracing works out of the box for the following frameworks: [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/), [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/),[Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/), [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/), [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/), [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/), [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlite](/platforms/python/guides/starlite/distributed-tracing/instrumentation/automatic-instrumentation/), [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/). - -If you have a vanilla Python project or use a (yet) unsupported framework you need to implement Custom Instrumentation. + From 7aca09b46f9f04b6ed99c99db2ddbe0f8aeec9f8 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Mon, 19 Jun 2023 15:08:10 +0200 Subject: [PATCH 025/116] Moved content to right places --- .../distributed-tracing/index/_default.mdx | 5 +- .../distributed-tracing/index/python.mdx | 9 +-- .../automatic-instrumentation/_default.mdx | 13 +--- .../python.django.mdx | 12 ++-- .../automatic-instrumentation/python.mdx | 61 +--------------- .../custom-instrumentation/python.mdx | 70 +++++++++++++++++-- 6 files changed, 80 insertions(+), 90 deletions(-) diff --git a/src/platform-includes/distributed-tracing/index/_default.mdx b/src/platform-includes/distributed-tracing/index/_default.mdx index 52149488f81c7..ea0b160485187 100644 --- a/src/platform-includes/distributed-tracing/index/_default.mdx +++ b/src/platform-includes/distributed-tracing/index/_default.mdx @@ -1,3 +1,6 @@ +# INDEX DEFAULT + -Please refer to tracing with and without performance activated and delete this note and its headline afterwards. + Please refer to tracing with and without performance activated and delete this + note and its headline afterwards. diff --git a/src/platform-includes/distributed-tracing/index/python.mdx b/src/platform-includes/distributed-tracing/index/python.mdx index 2bfd0e0ac48cc..05116b4ee0c06 100644 --- a/src/platform-includes/distributed-tracing/index/python.mdx +++ b/src/platform-includes/distributed-tracing/index/python.mdx @@ -1,8 +1,3 @@ - -Please refer to tracing with and without performance activated and delete this note and its headline afterwards. - +Distributed tracing works out of the box for the following frameworks: [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/), [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/), [Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/), [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/), [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/), [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/), [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlite](/platforms/python/guides/starlite/distributed-tracing/instrumentation/automatic-instrumentation/), [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/). - -Distributed tracing works out of the box for the following frameworks: [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/), [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/),[Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/), [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/), [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/), [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/), [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlite](/platforms/python/guides/starlite/distributed-tracing/instrumentation/automatic-instrumentation/), [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/). - -If you have a vanilla Python project or use a (yet) unsupported framework you need to implement Custom Instrumentation. +If you have a vanilla Python project or use a (yet) unsupported framework you need to implement Custom Instrumentation. diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/_default.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/_default.mdx index f640c9bea086f..a34f5d9f4a395 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/_default.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/_default.mdx @@ -1,15 +1,6 @@ # AUTOMATIC DEFAULT -Please refer to tracing with and without performance activated and delete this note and its headline afterwards. + Please refer to tracing with and without performance activated and delete this + note and its headline afterwards. - - -# OTHER NOTES -Automatic instrumentation is supported for the following frameworks: - -distributed tracing funktioniert ohne weiter config - -sucht in HTTP Headern und in Environment Variablen - --> page ausblenden wenn nicht supported diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.django.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.django.mdx index 4329a1ee2f8c9..ff5ccfda661f0 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.django.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.django.mdx @@ -1,10 +1,6 @@ -# AUTOMATIC PYTHON DJANGO +If you run a Django project **distributed tracing works out of the box**. - -Please refer to tracing with and without performance activated and delete this note and its headline afterwards. - - -If you run a Django project distributed tracing works out of the box. If requests to your Django project include the `sentry-trace` and `baggage` headers they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. +If requests to your Django project include the `sentry-trace` and `baggage` headers they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. You just need to initialize the Sentry SDK in your `settings.py` file and you are good to go: @@ -23,14 +19,14 @@ By default trace information (`sentry-trace` and `baggage` headers) will be adde ```python import sentry_sdk -from sentry_sdk.integrations.django import DjangoIntegration sentry_sdk.init( dsn="___PUBLIC_DSN___", trace_propagation_targets=[ "https://myproject.org", r"https://.*\.otherservice.org/.*", - ] + ], + # ... ) ``` diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.mdx index a6a047768a9aa..12810b8bbbfaf 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.mdx @@ -1,60 +1,3 @@ -# AUTOMATIC PYTHON +Distributed tracing works out of the box for the following frameworks: [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/), [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/), [Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/), [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/), [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/), [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/), [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlite](/platforms/python/guides/starlite/distributed-tracing/instrumentation/automatic-instrumentation/), [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/). - -Please refer to tracing with and without performance activated and delete this note and its headline afterwards. - - - -Distributed tracing works out of the box for the following frameworks: [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/), [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/),[Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/), [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/), [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/), [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/), [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlite](/platforms/python/guides/starlite/distributed-tracing/instrumentation/automatic-instrumentation/), [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/). - -If you are using one of the frameworks listed above, you do not need to do anything for distributed tracing to work! You can now stop reading this page and continue building and amazing product. - -If you have a vanilla Python project or use a (yet) unsupported framework you can still add distributed tracing to your project but need to it "by hand". - -Two things need to be done for distributed tracing to work: - -- When receiving incoming requests, parse and store incoming tracing information. -- When doing outgoing requests, add tracing information to the outgoing request. - -## Parse incoming tracing information - -Incoming tracing information has to be parsed and saved. -Incoming tracing can come from different places: - -- In a web environment it will be sent with HTTP headers. -- In a job queue (like Celery) the tracing information can be retrieved from some meta or header variables. -- You also can pick up tracing information from environment variables. - -```python -import sentry_sdk -from my_project import get_incoming_headers_as_dict - -headers = get_incoming_headers_as_dict() - -sentry_sdk.continue_trace(headers) -``` - -This will parse the given headers and try to find the `sentry-trace` and `baggage` headers and it will store them for later use. - -## Add tracing information to outgoing requests - -On outgoing requests to have to add the two headers `sentry-trace` and `baggage` that you parsed and stored earlier. - -If you are doing your HTTP requests with [Requests](https://requests.readthedocs.io/en/latest/), [AIOHTTP](https://docs.aiohttp.org/en/stable/), the low level [http.client](https://docs.python.org/3/library/http.client.html), or [httplib](https://docs.python.org/2/library/httplib.html) on Pyton 2 the parsed and stored headers are added automatically to outgoing requests. You do not need to do anything! - -If you do outgoing requests in another way you can prepare the headers like follows: - -```python -import sentry_sdk -from my_project import make_an_outgoing_request - -headers = {} -headers["sentry-trace"] = sentry_sdk.get_traceparent() -headers["baggage"] = sentry_sdk.get_baggage() - -make_an_outgoing_request(to="https://example.com", headers=headers) -``` - -Now tracing information is propagated to the project running at `https://example.com`. If it has the Python SDK with distributed tracing running, it will parse and save the tracing information for later use. - -The two services are now connect with distributed tracing. +If you have a vanilla Python project or use a (yet) unsupported framework you need to implement Custom Instrumentation. diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx index a62f11bf697ea..12cfe2b2ee391 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx @@ -1,5 +1,67 @@ -# CUSTOM PYTHON + - -Please refer to tracing with and without performance activated and delete this note and its headline afterwards. - +Distributed tracing **works out of the box** for the following frameworks: Django, FastAPI, Flask, Bottle, Falcon, Pyramid, Quart, Starlette, Starlite, Tornado. + +If you are using one of the frameworks listed above, **you do not need to do anything** for distributed tracing to work! + +You can stop reading this page now and continue building an amazing product. + + + +Please read the note above. If you have a vanilla Python project or use a (yet) unsupported framework you can still add distributed tracing to your project but need to it "by hand". + +Two things need to be done for distributed tracing to work: + +- When receiving incoming requests, parse and store incoming tracing information. +- When doing outgoing requests, add tracing information to the outgoing request. + +## Parse incoming tracing information + +Incoming tracing information has to be parsed and stored in memory for later use. +Incoming tracing information can come from different places: + +- In a web environment it will be sent with HTTP headers. (for example by another Sentry SDK used in your front end project) +- In a job queue (like Celery) the tracing information can be retrieved from meta or header variables. +- You also can pick up tracing information from environment variables. + +Whenever an incoming requests is processed by your project you need to do the following: + +```python +import sentry_sdk +from my_project import get_incoming_headers_as_dict + +headers = get_incoming_headers_as_dict() + +sentry_sdk.continue_trace(headers) +``` + +In this example `get_incoming_headers_as_dict()` returns a dictorary that contains the tracing information. This dictionary would have been populated with information from HTTP headers, environment variables, or any other mechanism your project uses to communicate with the outside world. + +Sentry's `continue_from_trace()` will parse the given headers and try to find the `sentry-trace` and `baggage` headers and it will store them in memory for later use. + +## Add tracing information to outgoing requests + +On outgoing requests you have to add the two headers `sentry-trace` and `baggage` that you parsed and stored earlier. + + + +If you are doing outgoing HTTP requests with Requests, AIOHTTP, the low level http.client (or httplib on Pyton 2) the parsed and stored tracing information is added automatically to outgoing requests. You do not need to do anything! + + + +If you are do outgoing requests in another way you can generate the tracing information like follows: + +```python +import sentry_sdk +from my_project import make_an_outgoing_request + +headers = {} +headers["sentry-trace"] = sentry_sdk.get_traceparent() +headers["baggage"] = sentry_sdk.get_baggage() + +make_an_outgoing_request(to="https://example.com", headers=headers) +``` + +Now tracing information is propagated to the project running at `https://example.com`. If it has the Python SDK running, it will parse and save the tracing information for later use. + +The two services are now connected with your custom distributed tracing implementation. From 2e4cd3adb83353b2a060e874abf871a98749e333 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Mon, 19 Jun 2023 16:43:38 +0200 Subject: [PATCH 026/116] General explanation what distributed tracing does. --- .../distributed-tracing-trace-propagation.png | Bin 0 -> 32897 bytes .../common/distributed-tracing/index.mdx | 59 ++++++++---------- 2 files changed, 27 insertions(+), 32 deletions(-) create mode 100644 src/platforms/common/distributed-tracing/distributed-tracing-trace-propagation.png diff --git a/src/platforms/common/distributed-tracing/distributed-tracing-trace-propagation.png b/src/platforms/common/distributed-tracing/distributed-tracing-trace-propagation.png new file mode 100644 index 0000000000000000000000000000000000000000..c4151fd71cfeac4e417b4bbf1c8eee8b091440dc GIT binary patch literal 32897 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 literal 0 HcmV?d00001 diff --git a/src/platforms/common/distributed-tracing/index.mdx b/src/platforms/common/distributed-tracing/index.mdx index a6bcd4f527ab5..51a02f33df135 100644 --- a/src/platforms/common/distributed-tracing/index.mdx +++ b/src/platforms/common/distributed-tracing/index.mdx @@ -4,33 +4,39 @@ sidebar_order: 40 description: "Learn how to connect backend and frontend transactions." --- -When tracing is enabled, the SDK will attach an outgoing header called `sentry-trace` to requests. This depends on the out of the box integrations we provide, but you can expect the header `sentry-trace` to be present. If it's not, you can manually add `sentry-trace` headers to any requests by learning more about [its structure](https://develop.sentry.dev/sdk/performance/#header-sentry-trace). +## What is distributed tracing? -SDKs with performance monitoring support listen to incoming requests and typically automatically pick up the incoming `sentry-trace` header to continue the trace (with the same `trace-id`) from there, connecting backend and frontend transactions into a single coherent trace using the `trace_id` value. Depending on the circumstance, this ID is transmitted either in a request header or in an HTML `` tag. +Applications can consist of multiple components, which are also called services. A web application for example can consist of a frontend, a backend and a microservice. A mobile app can alike constist of the mobile app running on the device and a backend and a microserivce. -All your transactions that have the same `trace-id` are connected. Linking transactions in this way makes it possible to navigate among them in [sentry.io](https://sentry.io) to better understand how the different parts of your system are affecting one another. You can learn more about this model in our [Distributed Tracing](/product/sentry-basics/tracing/distributed-tracing/) docs. +When a user triggeres an action in the frontend or the app it will call the backend which on its part calls the microservice. +So the users action leaves a trace through three services. - +Adding a unique trace ID to the users actions and passing it on from the frontend/app to the backend and further on to the microservice is called distributed tracing. -If the instrumentation you're using doesn't automatically pick up the `sentry-trace` header, you can also continue a trace manually by using the `continueFromHeaders` function on a `Transaction`. Learn more about this in our [Transaction Interface](https://develop.sentry.dev/sdk/performance/#new-span-and-transaction-classes) documentation. +![Trace propagation in Sentry SDK](distributed-tracing-trace-propagation.png) - +This way all the information that is collect on the frontend, the backend and the microservice is associated with one unique trace. Which makes it possible to relate information that was collected on the frontend with information collected in the backend or microservice - +You could for example see what UI element was clicked on the frontend that lead to an error in the microservice. This gives you the complete picture of what was happing in your application as a whole, not just what was happening in one service. - +## Configure - +Es gibt zwei header -# Temp +- `sentry-trace` +- `baggage` -Was ist dt und warum ist es cool? +TODO: header beschreiben +beispiel header anzeigen --> vielleicht etwas von der Produktseite übernehmen +Config fürs limitieren auf gewisse hosts +`trace-propagation-targets` -Ab welcher Version ist es supported? +Je nach User Setup in Firewalls / Proxies freischalten. + +jetzt neu: auch ohne performance! -# Supported frameworks +### Supported frameworks In the following frameworks distributed tracing works out of the box: @@ -54,31 +60,20 @@ TODO: Check these if there is really auto instrumentation: - rq --> -# Configure +If you have a vanilla Python project or use a (yet) unsupported framework you need to implement Custom Instrumentation. -Es gibt zwei header - -- `sentry-trace` -- `baggage` - -TODO: header beschreiben -beispiel header anzeigen - -Config fürs limitieren auf gewisse hosts -`trace-propagation-targets` - -Je nach User Setup in Firewalls / Proxies freischalten. - -jetzt neu: auch ohne performance! - -# Setup Your Other Services +## Setup Your Other Services -> Link to list of supported frameworks/guides or to frameworks/guides with performance enabled. -# Verify +## Verify Screenshots wie es aussehen soll und wo man in Sentry.io es sich ansehen kann. Von Instrumentationssue auf Trace Von Replay auf Trace + +## Temp + +Ab welcher Version ist es supported? From 645b52df3fe6e35f0e14c704a8460fe473fb3dbe Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Mon, 19 Jun 2023 16:53:08 +0200 Subject: [PATCH 027/116] Some more general discription what distributed tracing is --- .../common/distributed-tracing/index.mdx | 22 ++++++++++--------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/src/platforms/common/distributed-tracing/index.mdx b/src/platforms/common/distributed-tracing/index.mdx index 51a02f33df135..7a836d0a600dc 100644 --- a/src/platforms/common/distributed-tracing/index.mdx +++ b/src/platforms/common/distributed-tracing/index.mdx @@ -8,34 +8,36 @@ description: "Learn how to connect backend and frontend transactions." Applications can consist of multiple components, which are also called services. A web application for example can consist of a frontend, a backend and a microservice. A mobile app can alike constist of the mobile app running on the device and a backend and a microserivce. -When a user triggeres an action in the frontend or the app it will call the backend which on its part calls the microservice. +When a user triggeres an action in the frontend/app it will call the backend which on its part calls the microservice. So the users action leaves a trace through three services. Adding a unique trace ID to the users actions and passing it on from the frontend/app to the backend and further on to the microservice is called distributed tracing. -![Trace propagation in Sentry SDK](distributed-tracing-trace-propagation.png) - This way all the information that is collect on the frontend, the backend and the microservice is associated with one unique trace. Which makes it possible to relate information that was collected on the frontend with information collected in the backend or microservice You could for example see what UI element was clicked on the frontend that lead to an error in the microservice. This gives you the complete picture of what was happing in your application as a whole, not just what was happening in one service. -## Configure +## How does distributed tracing work in Sentry? + +The Sentry SDKs can inject tracing information into outgoing requests and can also extract tracing information from incoming requests. + +![Trace propagation in Sentry SDK](distributed-tracing-trace-propagation.png) -Es gibt zwei header +There are two headers that are used to propagate tracing information: - `sentry-trace` - `baggage` +For distributed tracing to work make sure that those headers are not blocked or stripped by your proxy servers or firefwalls. + +## Configure + TODO: header beschreiben -beispiel header anzeigen +TODO: beispiel header anzeigen Config fürs limitieren auf gewisse hosts `trace-propagation-targets` -Je nach User Setup in Firewalls / Proxies freischalten. - -jetzt neu: auch ohne performance! - ### Supported frameworks In the following frameworks distributed tracing works out of the box: From 6e2ca95651d33acd982a7a4d70cf3b9d43f931dc Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Mon, 19 Jun 2023 16:55:54 +0200 Subject: [PATCH 028/116] wording --- src/platform-includes/distributed-tracing/index/python.mdx | 2 +- .../instrumentation/automatic-instrumentation/python.mdx | 2 +- .../instrumentation/custom-instrumentation/python.mdx | 2 +- src/platforms/common/distributed-tracing/index.mdx | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/platform-includes/distributed-tracing/index/python.mdx b/src/platform-includes/distributed-tracing/index/python.mdx index 05116b4ee0c06..6d5a1889599ae 100644 --- a/src/platform-includes/distributed-tracing/index/python.mdx +++ b/src/platform-includes/distributed-tracing/index/python.mdx @@ -1,3 +1,3 @@ Distributed tracing works out of the box for the following frameworks: [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/), [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/), [Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/), [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/), [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/), [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/), [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlite](/platforms/python/guides/starlite/distributed-tracing/instrumentation/automatic-instrumentation/), [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/). -If you have a vanilla Python project or use a (yet) unsupported framework you need to implement Custom Instrumentation. +If you have a vanilla Python project or use an unsupported framework you need to implement Custom Instrumentation. diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.mdx index 12810b8bbbfaf..5edf8a88460b2 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.mdx @@ -1,3 +1,3 @@ Distributed tracing works out of the box for the following frameworks: [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/), [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/), [Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/), [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/), [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/), [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/), [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlite](/platforms/python/guides/starlite/distributed-tracing/instrumentation/automatic-instrumentation/), [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/). -If you have a vanilla Python project or use a (yet) unsupported framework you need to implement Custom Instrumentation. +If you have a vanilla Python project or us ean unsupported framework you need to implement Custom Instrumentation. diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx index 12cfe2b2ee391..4bbafad6f54d8 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx @@ -8,7 +8,7 @@ You can stop reading this page now and continue building an amazing product. -Please read the note above. If you have a vanilla Python project or use a (yet) unsupported framework you can still add distributed tracing to your project but need to it "by hand". +Please read the note above. If you have a vanilla Python project or use an unsupported framework you can still add distributed tracing to your project but need to it "by hand". Two things need to be done for distributed tracing to work: diff --git a/src/platforms/common/distributed-tracing/index.mdx b/src/platforms/common/distributed-tracing/index.mdx index 7a836d0a600dc..ffda2948b4df5 100644 --- a/src/platforms/common/distributed-tracing/index.mdx +++ b/src/platforms/common/distributed-tracing/index.mdx @@ -62,7 +62,7 @@ TODO: Check these if there is really auto instrumentation: - rq --> -If you have a vanilla Python project or use a (yet) unsupported framework you need to implement Custom Instrumentation. +If you have a vanilla Python project or use an unsupported framework you need to implement Custom Instrumentation. ## Setup Your Other Services From 4c1c6e01ef799a6e0a1c37a0f22b45de2626b09e Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Mon, 19 Jun 2023 17:02:29 +0200 Subject: [PATCH 029/116] Added trace to image --- .../distributed-tracing-trace-propagation.png | Bin 32897 -> 35087 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/src/platforms/common/distributed-tracing/distributed-tracing-trace-propagation.png b/src/platforms/common/distributed-tracing/distributed-tracing-trace-propagation.png index c4151fd71cfeac4e417b4bbf1c8eee8b091440dc..71de6fa954fc48b0281bb2d590befdb6083a5ba5 100644 GIT binary patch literal 35087 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 literal 32897 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 From b86fa89c3621aacd5b4ef497be7c0233003344aa Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Tue, 20 Jun 2023 13:32:42 +0200 Subject: [PATCH 030/116] Fixed links --- .../instrumentation/automatic-instrumentation/python.mdx | 2 +- .../instrumentation/custom-instrumentation.mdx | 2 +- src/platforms/common/profiling/index.mdx | 2 +- src/platforms/php/common/profiling/index.mdx | 2 +- src/platforms/php/guides/laravel/profiling/index.mdx | 2 +- src/platforms/php/guides/symfony/profiling/index.mdx | 2 +- 6 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.mdx index 5edf8a88460b2..9a4039d6eb9c6 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.mdx @@ -1,3 +1,3 @@ Distributed tracing works out of the box for the following frameworks: [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/), [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/), [Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/), [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/), [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/), [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/), [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlite](/platforms/python/guides/starlite/distributed-tracing/instrumentation/automatic-instrumentation/), [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/). -If you have a vanilla Python project or us ean unsupported framework you need to implement Custom Instrumentation. +If you have a vanilla Python project or us ean unsupported framework you need to implement Custom Instrumentation. diff --git a/src/platforms/common/distributed-tracing/instrumentation/custom-instrumentation.mdx b/src/platforms/common/distributed-tracing/instrumentation/custom-instrumentation.mdx index 224e8b03d0fed..ab9aadd81fa8b 100644 --- a/src/platforms/common/distributed-tracing/instrumentation/custom-instrumentation.mdx +++ b/src/platforms/common/distributed-tracing/instrumentation/custom-instrumentation.mdx @@ -8,4 +8,4 @@ supported: - python --- - + diff --git a/src/platforms/common/profiling/index.mdx b/src/platforms/common/profiling/index.mdx index 4b2bd99b78038..dade5240cf99a 100644 --- a/src/platforms/common/profiling/index.mdx +++ b/src/platforms/common/profiling/index.mdx @@ -334,7 +334,7 @@ If you don't see any profiling data in [sentry.io](https://sentry.io), you can t - Ensure that performance monitoring is enabled. - Ensure that the automatic instrumentation is sending performance data to Sentry by going to the **Performance** page in [sentry.io](https://sentry.io). -- If the automatic instrumentation is not sending performance data, try using custom instrumentation. +- If the automatic instrumentation is not sending performance data, try using custom instrumentation. - Enable debug mode in the SDK and check the logs. diff --git a/src/platforms/php/common/profiling/index.mdx b/src/platforms/php/common/profiling/index.mdx index 1b9cf5ccb4d6f..f4fbf68b798fc 100644 --- a/src/platforms/php/common/profiling/index.mdx +++ b/src/platforms/php/common/profiling/index.mdx @@ -99,4 +99,4 @@ After you've set up Relay, you should see a dramatic improvement in how much you If you don't see any profiling data in [sentry.io](https://sentry.io), you can try the following: - Ensure that performance monitoring is enabled. -- Ensure that the custom instrumentation is sending performance data to Sentry by going to the **Performance** page in [sentry.io](https://sentry.io). +- Ensure that the custom instrumentation is sending performance data to Sentry by going to the **Performance** page in [sentry.io](https://sentry.io). diff --git a/src/platforms/php/guides/laravel/profiling/index.mdx b/src/platforms/php/guides/laravel/profiling/index.mdx index 25424a760a341..09db7379fff76 100644 --- a/src/platforms/php/guides/laravel/profiling/index.mdx +++ b/src/platforms/php/guides/laravel/profiling/index.mdx @@ -94,4 +94,4 @@ If you don't see any profiling data in [sentry.io](https://sentry.io), you can t - Ensure that performance monitoring is enabled. - Ensure that the automatic instrumentation is sending performance data to Sentry by going to the **Performance** page in [sentry.io](https://sentry.io). -- If the automatic instrumentation is not sending performance data, try using custom instrumentation. +- If the automatic instrumentation is not sending performance data, try using custom instrumentation. diff --git a/src/platforms/php/guides/symfony/profiling/index.mdx b/src/platforms/php/guides/symfony/profiling/index.mdx index d48884cd8a45e..c58b59dbc22ce 100644 --- a/src/platforms/php/guides/symfony/profiling/index.mdx +++ b/src/platforms/php/guides/symfony/profiling/index.mdx @@ -100,4 +100,4 @@ If you don't see any profiling data in [sentry.io](https://sentry.io), you can t - Ensure that performance monitoring is enabled. - Ensure that the automatic instrumentation is sending performance data to Sentry by going to the **Performance** page in [sentry.io](https://sentry.io). -- If the automatic instrumentation is not sending performance data, try using custom instrumentation. +- If the automatic instrumentation is not sending performance data, try using custom instrumentation. From 866c17f04a2ef1819282199e2f854f678443cca9 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Tue, 20 Jun 2023 13:34:40 +0200 Subject: [PATCH 031/116] Fixed links --- .../instrumentation/automatic-instrumentation/python.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.mdx index 9a4039d6eb9c6..635503c6fbb00 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.mdx @@ -1,3 +1,3 @@ Distributed tracing works out of the box for the following frameworks: [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/), [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/), [Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/), [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/), [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/), [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/), [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlite](/platforms/python/guides/starlite/distributed-tracing/instrumentation/automatic-instrumentation/), [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/). -If you have a vanilla Python project or us ean unsupported framework you need to implement Custom Instrumentation. +If you have a vanilla Python project or us ean unsupported framework you need to implement Custom Instrumentation. From 761b6ff3edc11361c8a3b3527f21b3d9e361c01a Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Tue, 20 Jun 2023 13:37:38 +0200 Subject: [PATCH 032/116] Fixed links --- src/platforms/php/guides/laravel/profiling/index.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platforms/php/guides/laravel/profiling/index.mdx b/src/platforms/php/guides/laravel/profiling/index.mdx index 09db7379fff76..566b99471ad59 100644 --- a/src/platforms/php/guides/laravel/profiling/index.mdx +++ b/src/platforms/php/guides/laravel/profiling/index.mdx @@ -94,4 +94,4 @@ If you don't see any profiling data in [sentry.io](https://sentry.io), you can t - Ensure that performance monitoring is enabled. - Ensure that the automatic instrumentation is sending performance data to Sentry by going to the **Performance** page in [sentry.io](https://sentry.io). -- If the automatic instrumentation is not sending performance data, try using custom instrumentation. +- If the automatic instrumentation is not sending performance data, try using custom instrumentation. From 832c952a02bbc6ab70985537323a511e938c2dcd Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Tue, 20 Jun 2023 14:52:45 +0200 Subject: [PATCH 033/116] Some work --- .../python.django.mdx | 4 ++ .../custom-instrumentation/python.mdx | 4 ++ .../common/distributed-tracing/index.mdx | 42 +++++++++---------- 3 files changed, 29 insertions(+), 21 deletions(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.django.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.django.mdx index ff5ccfda661f0..3fb4115d23965 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.django.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation/python.django.mdx @@ -33,3 +33,7 @@ sentry_sdk.init( In this example trace information will be added to all requests to URLs that contain `"https://myproject.org"` or to all ULRs of all sub domains of `otherservice.org` like `https://api.otherservice.org/something/`, `https://payment.otherservice.org/something/` and so on. See `trace_propagation_targets` documentation for more information about this option. + +## Verification + +If you make outgoing HTTP requests from your project to other services, check if the HTTP headers `sentry-trace` and `baggage` are present in the request. If so distributed tracing is working. diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx index 4bbafad6f54d8..e151b8059e9a4 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx @@ -65,3 +65,7 @@ make_an_outgoing_request(to="https://example.com", headers=headers) Now tracing information is propagated to the project running at `https://example.com`. If it has the Python SDK running, it will parse and save the tracing information for later use. The two services are now connected with your custom distributed tracing implementation. + +## Verification + +If you make outgoing requests from your project to other services, check if the headers `sentry-trace` and `baggage` are present in the request. If so distributed tracing is working. diff --git a/src/platforms/common/distributed-tracing/index.mdx b/src/platforms/common/distributed-tracing/index.mdx index ffda2948b4df5..5cdc1a60dfa62 100644 --- a/src/platforms/common/distributed-tracing/index.mdx +++ b/src/platforms/common/distributed-tracing/index.mdx @@ -28,30 +28,26 @@ There are two headers that are used to propagate tracing information: - `sentry-trace` - `baggage` -For distributed tracing to work make sure that those headers are not blocked or stripped by your proxy servers or firefwalls. + -## Configure +For distributed tracing to work make sure that those headers are not blocked or stripped by your proxy servers or firewalls. -TODO: header beschreiben -TODO: beispiel header anzeigen + -Config fürs limitieren auf gewisse hosts -`trace-propagation-targets` + -### Supported frameworks + + +## Configuration + +Distributed tracing **works out of the box** for the following Python frameworks: Django, FastAPI, Flask, Bottle, Falcon, Pyramid, Quart, Starlette, Starlite, Tornado. + +If you are using one of the frameworks listed above, **you do not need to do anything** for distributed tracing to work. Link to list of supported frameworks/guides or to frameworks/guides with performance enabled. +Setup the Sentry SDK for all your other connected services. Check the Sentry documentation of the languages your connected services are written in if distributed tracing is supported out of the box, or if you need to do some custom instrumentation. + +Maybe you want to check out the Javascript documentation to learn [how to setup distributed tracing in your frontend](/platforms/javascript/performance/connect-services/). -## Verify + From 19f480193998fc5d9bbae8f4baa695530a3938d1 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Tue, 20 Jun 2023 15:17:47 +0200 Subject: [PATCH 034/116] Split stuff up into separate files --- .../configuration/_default.mdx | 1 + .../configuration/python.mdx | 24 +++++++++++++ .../other-services/_default.mdx | 1 + .../other-services/python.mdx | 7 ++++ .../common/distributed-tracing/index.mdx | 36 ++----------------- 5 files changed, 35 insertions(+), 34 deletions(-) create mode 100644 src/platform-includes/distributed-tracing/configuration/_default.mdx create mode 100644 src/platform-includes/distributed-tracing/configuration/python.mdx create mode 100644 src/platform-includes/distributed-tracing/other-services/_default.mdx create mode 100644 src/platform-includes/distributed-tracing/other-services/python.mdx diff --git a/src/platform-includes/distributed-tracing/configuration/_default.mdx b/src/platform-includes/distributed-tracing/configuration/_default.mdx new file mode 100644 index 0000000000000..aa8fc28701a99 --- /dev/null +++ b/src/platform-includes/distributed-tracing/configuration/_default.mdx @@ -0,0 +1 @@ + diff --git a/src/platform-includes/distributed-tracing/configuration/python.mdx b/src/platform-includes/distributed-tracing/configuration/python.mdx new file mode 100644 index 0000000000000..85bb2c093ab45 --- /dev/null +++ b/src/platform-includes/distributed-tracing/configuration/python.mdx @@ -0,0 +1,24 @@ +## Configuration + +Distributed tracing works out of the box for the following Python frameworks: Django, FastAPI, Flask, Bottle, Falcon, Pyramid, Quart, Starlette, Starlite, Tornado. + +If you are using one of the frameworks listed above, you do not need to do anything for distributed tracing to work. + +If you have a vanilla Python project or use an unsupported framework you need to implement Custom Instrumentation. + + + +In Python SDKs version `1.25.x` and below you need to have "Sentry Performance" enabled for distributed tracing to work. Learn more in Set Up Performance. + + + + diff --git a/src/platform-includes/distributed-tracing/other-services/_default.mdx b/src/platform-includes/distributed-tracing/other-services/_default.mdx new file mode 100644 index 0000000000000..01e70a488d2ab --- /dev/null +++ b/src/platform-includes/distributed-tracing/other-services/_default.mdx @@ -0,0 +1 @@ + diff --git a/src/platform-includes/distributed-tracing/other-services/python.mdx b/src/platform-includes/distributed-tracing/other-services/python.mdx new file mode 100644 index 0000000000000..239b425a46226 --- /dev/null +++ b/src/platform-includes/distributed-tracing/other-services/python.mdx @@ -0,0 +1,7 @@ +## Setup Your Other Services + +Setup the Sentry SDK for all your other connected services. Check the Sentry documentation of the languages your connected services are written in if distributed tracing is supported out of the box, or if you need to do some custom instrumentation. + +Maybe you want to check out the Javascript documentation to learn [how to setup distributed tracing in your frontend](/platforms/javascript/performance/connect-services/). + +# TODO: FIX LINK TO JAVASCRIPT DISTRIBUTED TRACING diff --git a/src/platforms/common/distributed-tracing/index.mdx b/src/platforms/common/distributed-tracing/index.mdx index 5cdc1a60dfa62..a8f599165f07b 100644 --- a/src/platforms/common/distributed-tracing/index.mdx +++ b/src/platforms/common/distributed-tracing/index.mdx @@ -28,43 +28,11 @@ There are two headers that are used to propagate tracing information: - `sentry-trace` - `baggage` - - For distributed tracing to work make sure that those headers are not blocked or stripped by your proxy servers or firewalls. - - - - - - -## Configuration - -Distributed tracing **works out of the box** for the following Python frameworks: Django, FastAPI, Flask, Bottle, Falcon, Pyramid, Quart, Starlette, Starlite, Tornado. - -If you are using one of the frameworks listed above, **you do not need to do anything** for distributed tracing to work. - - - -If you have a vanilla Python project or use an unsupported framework you need to implement Custom Instrumentation. - -## Setup Your Other Services - -Setup the Sentry SDK for all your other connected services. Check the Sentry documentation of the languages your connected services are written in if distributed tracing is supported out of the box, or if you need to do some custom instrumentation. + -Maybe you want to check out the Javascript documentation to learn [how to setup distributed tracing in your frontend](/platforms/javascript/performance/connect-services/). + + Distributed tracing **works out of the box** if you have "Performance Monitoring" enable and use one of Sentry's tracing-related integrations (`BrowserTracing`, `Http`, and `Express`), or the [Next.JS SDK](/platforms/javascript/guides/nextjs/). diff --git a/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx b/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx index 88e26d429ea97..a61485ffd3fbc 100644 --- a/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx +++ b/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx @@ -3,9 +3,7 @@ title: Automatic Instrumentation sidebar_order: 40 description: "" supported: - - java - javascript - - php - python --- diff --git a/src/platforms/common/distributed-tracing/instrumentation/custom-instrumentation.mdx b/src/platforms/common/distributed-tracing/instrumentation/custom-instrumentation.mdx index 43c3fb4cc7712..a673cc74c48dc 100644 --- a/src/platforms/common/distributed-tracing/instrumentation/custom-instrumentation.mdx +++ b/src/platforms/common/distributed-tracing/instrumentation/custom-instrumentation.mdx @@ -3,9 +3,6 @@ title: Custom Instrumentation sidebar_order: 40 description: "" supported: - - java - - javascript - - php - python --- diff --git a/src/platforms/common/performance/connect-services.mdx b/src/platforms/common/performance/connect-services.mdx index 87ea82a8f2ecd..3e84e775e5163 100644 --- a/src/platforms/common/performance/connect-services.mdx +++ b/src/platforms/common/performance/connect-services.mdx @@ -4,7 +4,6 @@ sidebar_order: 40 description: "Learn how to connect backend and frontend transactions." notSupported: - javascript - - php - python --- From 6418ac578aa2bc9273c7ca0158ae468ac5edf7ba Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Thu, 22 Jun 2023 12:16:24 +0200 Subject: [PATCH 056/116] Fixed link --- .../distributed-tracing/other-services/python.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/other-services/python.mdx b/src/platform-includes/distributed-tracing/other-services/python.mdx index 56423a23f3edd..50299487d24bf 100644 --- a/src/platform-includes/distributed-tracing/other-services/python.mdx +++ b/src/platform-includes/distributed-tracing/other-services/python.mdx @@ -2,7 +2,7 @@ Setup the Sentry SDK for all your other connected services. Check the Sentry documentation of the languages your connected services are written in if distributed tracing is supported out of the box, or if you need to do some custom instrumentation. -Check out the Javascript documentation to learn [how to setup distributed tracing in your frontend](/platforms/javascript/distributed-tracing/#configuration). +Check out the Javascript documentation to learn [how to setup distributed tracing in your frontend](/platforms/javascript/distributed-tracing/instrumentation/automatic-instrumentation/). ### CORS headers From 701db811bba12f6e05c357c24ce06a84612cca10 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Thu, 22 Jun 2023 14:15:00 +0200 Subject: [PATCH 057/116] Fixed some links --- src/platforms/common/configuration/sampling.mdx | 12 ------------ src/platforms/common/distributed-tracing/index.mdx | 2 ++ .../instrumentation/automatic-instrumentation.mdx | 2 ++ .../instrumentation/custom-instrumentation.mdx | 2 ++ .../distributed-tracing/instrumentation/index.mdx | 4 ++-- src/platforms/common/performance/index.mdx | 7 +------ .../node/guides/express/performance/index.mdx | 7 +------ .../laravel/performance/distributed-tracing.mdx | 2 +- 8 files changed, 11 insertions(+), 27 deletions(-) diff --git a/src/platforms/common/configuration/sampling.mdx b/src/platforms/common/configuration/sampling.mdx index 7d57fd6f9e139..70141dfbc9ba6 100644 --- a/src/platforms/common/configuration/sampling.mdx +++ b/src/platforms/common/configuration/sampling.mdx @@ -109,18 +109,6 @@ When using custom instrumentation to create a transaction, you can add data to t Whatever a transaction's sampling decision, that decision will be passed to its child spans and from there to any transactions they subsequently cause in other services. - - -(See Connecting Services for more about how that propagation is done.) - - - - - -(See [Connecting Services](/platforms/php/guides/laravel/performance/connect-services/) for more about how that propagation is done.) - - - If the transaction currently being created is one of those subsequent transactions (in other words, if it has a parent transaction), the upstream (parent) sampling decision will always be included in the sampling context data, so that your can choose whether and when to inherit that decision. (In most cases, inheritance is the right choice, to avoid partial traces.) diff --git a/src/platforms/common/distributed-tracing/index.mdx b/src/platforms/common/distributed-tracing/index.mdx index d26e050b5b8ca..6b662c51b71c9 100644 --- a/src/platforms/common/distributed-tracing/index.mdx +++ b/src/platforms/common/distributed-tracing/index.mdx @@ -5,6 +5,8 @@ description: "Learn how to connect backend and frontend transactions." supported: - javascript - python +notSupported: + - javascript.cordova --- ## What Is Distributed Tracing? diff --git a/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx b/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx index a61485ffd3fbc..1943539925eef 100644 --- a/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx +++ b/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx @@ -5,6 +5,8 @@ description: "" supported: - javascript - python +notSupported: + - javascript.cordova --- diff --git a/src/platforms/common/distributed-tracing/instrumentation/custom-instrumentation.mdx b/src/platforms/common/distributed-tracing/instrumentation/custom-instrumentation.mdx index a673cc74c48dc..b888dacba3e5b 100644 --- a/src/platforms/common/distributed-tracing/instrumentation/custom-instrumentation.mdx +++ b/src/platforms/common/distributed-tracing/instrumentation/custom-instrumentation.mdx @@ -4,6 +4,8 @@ sidebar_order: 40 description: "" supported: - python +notSupported: + - javascript.cordova --- diff --git a/src/platforms/common/distributed-tracing/instrumentation/index.mdx b/src/platforms/common/distributed-tracing/instrumentation/index.mdx index 2b6840961b4fe..766429d4c7ed3 100644 --- a/src/platforms/common/distributed-tracing/instrumentation/index.mdx +++ b/src/platforms/common/distributed-tracing/instrumentation/index.mdx @@ -3,10 +3,10 @@ title: Instrumentation sidebar_order: 40 description: "" supported: - - java - javascript - - php - python +notSupported: + - javascript.cordova --- diff --git a/src/platforms/common/performance/index.mdx b/src/platforms/common/performance/index.mdx index 12ed959f50e53..f64638ceed08e 100644 --- a/src/platforms/common/performance/index.mdx +++ b/src/platforms/common/performance/index.mdx @@ -108,12 +108,7 @@ If you leave your sample rate at `1.0`, a transaction will be sent every time a ## Connecting Services -If you are also using Performance Monitoring for [JavaScript](/platforms/javascript/performance/), depending on where your request originates, you can connect traces: - -1. For requests that start in your backend, by [adding a meta tag](/platforms/javascript/performance/connect-services/#pageload) in your HTML template that contains tracing information. -2. For requests that start in JavaScript, by the SDK [setting a header](/platforms/javascript/performance/connect-services/#navigation-and-other-xhr-requests) on requests to your backend. - -Otherwise, backend services with Performance Monitoring connect automatically. +If you are also using Performance Monitoring for [JavaScript](/platforms/javascript/performance/), you can connect the frontend and the backend service by enabling [Distributed Tracing](/platforms/javascript/distributed-tracing/). diff --git a/src/platforms/node/guides/express/performance/index.mdx b/src/platforms/node/guides/express/performance/index.mdx index 875865aee4f58..44c91e7053ac0 100644 --- a/src/platforms/node/guides/express/performance/index.mdx +++ b/src/platforms/node/guides/express/performance/index.mdx @@ -131,9 +131,4 @@ app.get("/success", function successHandler(req, res) { ## Connecting Services -If you are also using Performance Monitoring for [JavaScript](/platforms/javascript/performance/), depending on where your request originates, you can connect traces: - -1. For requests that start in your backend, by [adding a meta tag](/platforms/javascript/performance/connect-services/#pageload) in your HTML template that contains tracing information. -2. For requests that start in JavaScript, by the SDK [setting a header](/platforms/javascript/performance/connect-services/#navigation-and-other-xhr-requests) on requests to your backend. - -Otherwise, backend services with Performance Monitoring connect automatically. +If you are also using Performance Monitoring for [JavaScript](/platforms/javascript/performance/), you can connect the frontend and the backend service by enabling [Distributed Tracing](/platforms/javascript/distributed-tracing/). diff --git a/src/platforms/php/guides/laravel/performance/distributed-tracing.mdx b/src/platforms/php/guides/laravel/performance/distributed-tracing.mdx index 84f57ffa9f8a3..155f282e7d907 100644 --- a/src/platforms/php/guides/laravel/performance/distributed-tracing.mdx +++ b/src/platforms/php/guides/laravel/performance/distributed-tracing.mdx @@ -4,7 +4,7 @@ sidebar_order: 40 description: "Learn how to connect backend and frontend transactions." --- -If you're also using Performance Monitoring for [JavaScript](/platforms/javascript/performance/), you can use a helper function to continue the trace and propagate the trace context started from your backend in order to [connect services](/platforms/javascript/performance/connect-services/#navigation-and-other-xhr-requests). (The trace context contains additional trace-related data that is used for trace-based sampling.) +If you're also using Performance Monitoring for [JavaScript](/platforms/javascript/performance/), you can use a helper function to continue the trace and propagate the trace context started from your backend in order to enable [Distributed Tracing](/platforms/javascript/distributed-tracing/). (The trace context contains additional trace-related data that is used for trace-based sampling.) Add the following line to your blade template rendering the `` of your page: ```php {filename:app.blade.php} From 5ecde093e15c79c0d350d6a8502c853a2abee89d Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Thu, 22 Jun 2023 14:19:18 +0200 Subject: [PATCH 058/116] Fixed more links --- .../instrumentation/custom-instrumentation/python.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx index 67abd268561f0..d0afa46fb3e17 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx @@ -57,7 +57,7 @@ with start_transaction(transaction=transaction) as transaction: do_some_heavy_lifting() ``` -See the [Performance Monitoring Documentation](/performance/instrumentation/custom-instrumentation/) to learn what you can do with transactions. +See the Performance Monitoring Documentation to learn what you can do with transactions. ## Inject Tracing Information to Outgoing Requests From 0082b412d374d4c29ecc741f97c0f013c9848b75 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Fri, 23 Jun 2023 11:36:04 +0200 Subject: [PATCH 059/116] Update src/platforms/common/distributed-tracing/index.mdx Co-authored-by: Shana Matthews --- src/platforms/common/distributed-tracing/index.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platforms/common/distributed-tracing/index.mdx b/src/platforms/common/distributed-tracing/index.mdx index 6b662c51b71c9..cc9a455754f94 100644 --- a/src/platforms/common/distributed-tracing/index.mdx +++ b/src/platforms/common/distributed-tracing/index.mdx @@ -1,7 +1,7 @@ --- title: Distributed Tracing sidebar_order: 40 -description: "Learn how to connect backend and frontend transactions." +description: "Learn how to connect frontend and backend transactions." supported: - javascript - python From 0f9baa44abe7476d139f2f97d5a4bc8954b43a71 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Fri, 23 Jun 2023 11:37:07 +0200 Subject: [PATCH 060/116] Update src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx Co-authored-by: Shana Matthews --- .../automatic-instrumentation-configuration/javascript.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx index bd112dc60148f..9659c7ac8adf6 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx @@ -15,7 +15,7 @@ Sentry.init({ }); ``` -In this example trace information will be added to outgoing XHR/fetch requests to `localhost` and URLs starting with `https://api.example.com`. +In this example, trace information will be added to outgoing XHR/fetch requests to `localhost` and URLs starting with `https://api.example.com`. See tracePropagationTargets documentation to learn more. From 7b052e5d45b7fd83990d5e03bf779afa171e47e1 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Fri, 23 Jun 2023 11:37:23 +0200 Subject: [PATCH 061/116] Update src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-verification/javascript.mdx Co-authored-by: Shana Matthews --- .../automatic-instrumentation-verification/javascript.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-verification/javascript.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-verification/javascript.mdx index 9087bd1f03699..b45b75e81ba62 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-verification/javascript.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-verification/javascript.mdx @@ -1,3 +1,3 @@ ## Verification -If you make outgoing XHR/fetch requests from your project to other services, check if the HTTP headers `sentry-trace` and `baggage` are present in the request. If so distributed tracing is working. +If you make outgoing XHR/fetch requests from your project to other services, check if the HTTP headers `sentry-trace` and `baggage` are present in the request. If so, distributed tracing is working. From bfe0997e08851fe4f2c8437de2dc50339eec2d77 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Fri, 23 Jun 2023 11:37:51 +0200 Subject: [PATCH 062/116] Update src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx Co-authored-by: Shana Matthews --- .../automatic-instrumentation-configuration/javascript.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx index 9659c7ac8adf6..72fc56af14e06 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx @@ -17,7 +17,7 @@ Sentry.init({ In this example, trace information will be added to outgoing XHR/fetch requests to `localhost` and URLs starting with `https://api.example.com`. -See tracePropagationTargets documentation to learn more. +See docs on `tracePropagationTargets` to learn more. ### CORS headers From 0d7922dd2e29c13aad574d1028f7470f4101da85 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Fri, 23 Jun 2023 11:38:11 +0200 Subject: [PATCH 063/116] Update src/platforms/common/distributed-tracing/index.mdx Co-authored-by: Shana Matthews --- src/platforms/common/distributed-tracing/index.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platforms/common/distributed-tracing/index.mdx b/src/platforms/common/distributed-tracing/index.mdx index cc9a455754f94..e1641f908e505 100644 --- a/src/platforms/common/distributed-tracing/index.mdx +++ b/src/platforms/common/distributed-tracing/index.mdx @@ -24,7 +24,7 @@ You could for example see what UI element was clicked on the frontend that lead ## How Does Distributed Tracing Work in Sentry? -The Sentry SDKs can inject tracing information into outgoing requests and can also extract tracing information from incoming requests. +Sentry SDKs inject tracing information into outgoing requests and extract tracing information from incoming requests. ![Trace propagation in Sentry SDK](distributed-tracing-trace-propagation.png) From eb61839540078ede50c57adb6796c87595a4fce9 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Fri, 23 Jun 2023 11:57:50 +0200 Subject: [PATCH 064/116] Better wording on integrations/frameworks that work out of the box. --- .../distributed-tracing/configuration/javascript.mdx | 2 +- src/platform-includes/distributed-tracing/index/javascript.mdx | 2 +- .../automatic-instrumentation-intro/javascript.mdx | 2 +- .../instrumentation/custom-instrumentation/javascript.mdx | 2 +- .../performance/connect-services/javascript.mdx | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/platform-includes/distributed-tracing/configuration/javascript.mdx b/src/platform-includes/distributed-tracing/configuration/javascript.mdx index 2b7157f28f03b..7d618b3cddf0a 100644 --- a/src/platform-includes/distributed-tracing/configuration/javascript.mdx +++ b/src/platform-includes/distributed-tracing/configuration/javascript.mdx @@ -1,6 +1,6 @@ ## Configuration -All of Sentry's tracing-related integrations (`BrowserTracing`, `Http`, and `Express`), as well as the [Next.JS SDK](/platforms/javascript/guides/nextjs/), support distributed tracing out of the box. +All Sentry JavaScript SDKs support distributed tracing out of the box if you add the BrowserTracing integration to your `Sentry.init` option. The Next.js and SvelteKit SDKs already include this integration by default. diff --git a/src/platform-includes/distributed-tracing/index/javascript.mdx b/src/platform-includes/distributed-tracing/index/javascript.mdx index 53aabf1359caa..a9a8ec5f284d9 100644 --- a/src/platform-includes/distributed-tracing/index/javascript.mdx +++ b/src/platform-includes/distributed-tracing/index/javascript.mdx @@ -1,3 +1,3 @@ -All of Sentry's tracing-related integrations (`BrowserTracing`, `Http`, and `Express`), as well as the [Next.JS SDK](/platforms/javascript/guides/nextjs/), support distributed tracing out of the box. +All Sentry JavaScript SDKs support distributed tracing out of the box if you add the BrowserTracing integration to your `Sentry.init` option. The Next.js and SvelteKit SDKs already include this integration by default. See Automatic Instrumentation to learn more. diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/javascript.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/javascript.mdx index 77723ca2203f8..4a8d18ae8d8ac 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/javascript.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/javascript.mdx @@ -1,4 +1,4 @@ -All of Sentry's tracing-related integrations (`BrowserTracing`, `Http`, and `Express`), as well as the [Next.JS SDK](/platforms/javascript/guides/nextjs/), support distributed tracing out of the box. +All Sentry JavaScript SDKs support distributed tracing out of the box if you add the BrowserTracing integration to your `Sentry.init` option. The Next.js and SvelteKit SDKs already include this integration by default. Tracing information sent from the backend via the `sentry-tracing` and `baggage` HTML `meta` tags will be extracted and stored in a transaction that is created at page load. diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx index 3ee091d4c13c2..71210f4841f22 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx @@ -10,7 +10,7 @@ then revisit this page and change it to match the new official apis to use. -Distributed tracing **works out of the box** if you have "Performance Monitoring" enable and use one of Sentry's tracing-related integrations (`BrowserTracing`, `Http`, and `Express`), or the [Next.JS SDK](/platforms/javascript/guides/nextjs/). +All Sentry JavaScript SDKs support distributed tracing out of the box if you add the BrowserTracing integration to your `Sentry.init` option. The Next.js and SvelteKit SDKs already include this integration by default. If you are using one of the integrations of Frameworks listed above, **you do not need to do anything** for distributed tracing to work! diff --git a/src/platform-includes/performance/connect-services/javascript.mdx b/src/platform-includes/performance/connect-services/javascript.mdx index eefc93ca7e398..4f3573eb52da8 100644 --- a/src/platform-includes/performance/connect-services/javascript.mdx +++ b/src/platform-includes/performance/connect-services/javascript.mdx @@ -8,7 +8,7 @@ The `baggage` header was added with version 7 of the Sentry Javascript SDK and i -All of Sentry's tracing-related integrations (`BrowserTracing`, `Http`, and `Express`), as well as the Next.JS SDK, either generate or pick up and propagate the trace headers automatically, as appropriate, for all transactions and spans that they generate. +All Sentry JavaScript SDKs support distributed tracing out of the box if you add the BrowserTracing integration to your `Sentry.init` option. The Next.js and SvelteKit SDKs already include this integration by default. The JavaScript SDK will only attach the trace headers to outgoing HTTP requests for which the destination is a substring or regex match to the tracePropagationTargets list. `tracePropagationTargets` was previously called `tracingOrigins`. From d09de532647c7b2e645a17d89f2139bf628c9634 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Fri, 23 Jun 2023 13:56:54 +0200 Subject: [PATCH 065/116] Reworked cors headers docs --- .../distributed-tracing/configuration/javascript.mdx | 2 ++ .../distributed-tracing/configuration/python.mdx | 2 -- .../javascript.mdx | 12 ++++++++---- .../python.mdx | 8 ++++++++ .../other-services/javascript.mdx | 3 --- .../distributed-tracing/other-services/python.mdx | 8 +++----- 6 files changed, 21 insertions(+), 14 deletions(-) delete mode 100644 src/platform-includes/distributed-tracing/other-services/javascript.mdx diff --git a/src/platform-includes/distributed-tracing/configuration/javascript.mdx b/src/platform-includes/distributed-tracing/configuration/javascript.mdx index 7d618b3cddf0a..12a640adc1816 100644 --- a/src/platform-includes/distributed-tracing/configuration/javascript.mdx +++ b/src/platform-includes/distributed-tracing/configuration/javascript.mdx @@ -2,6 +2,8 @@ All Sentry JavaScript SDKs support distributed tracing out of the box if you add the BrowserTracing integration to your `Sentry.init` option. The Next.js and SvelteKit SDKs already include this integration by default. +In case your backend lives on a differnt domain, you might need to Configure Backend CORS Headers. + **You need to have "Performance Monitoring" enabled!** See Set Up Performance on how to enable performance monitoring. diff --git a/src/platform-includes/distributed-tracing/configuration/python.mdx b/src/platform-includes/distributed-tracing/configuration/python.mdx index 741496baba7d4..3169d3b5e2cd1 100644 --- a/src/platform-includes/distributed-tracing/configuration/python.mdx +++ b/src/platform-includes/distributed-tracing/configuration/python.mdx @@ -2,8 +2,6 @@ Distributed tracing works out of the box for the following Python frameworks: Django, FastAPI, Flask, Bottle, Falcon, Pyramid, Quart, Starlette, Tornado. -If you are using one of the frameworks listed above, you do not need to do anything for distributed tracing to work. - If you have a vanilla Python project or use an unsupported framework you need to implement Custom Instrumentation. diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx index 72fc56af14e06..402790820f9ec 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx @@ -1,8 +1,8 @@ ## Configuration -By default trace information (`sentry-trace` and `baggage` headers) will be added to outgoing XHR/fetch requests that contain `localhost` in their URL or requests whose URL starts with a `'/'` (for example `/api/v1/users`). +By default, trace information (`sentry-trace` and `baggage` headers) will be added to outgoing XHR/fetch requests that contain `localhost` in their URL and requests where the URL starts with `'/'`, for example, `/api/v1/users`. -If you want to configure to what URLs the trace information should be added you can add an `tracePropagationTargets` option: +To configure which URLs have trace information added, set the `tracePropagationTargets` option: ```javascript Sentry.init({ @@ -19,6 +19,10 @@ In this example, trace information will be added to outgoing XHR/fetch requests See docs on `tracePropagationTargets` to learn more. -### CORS headers +### Configure Backend CORS Headers -If your frontend project does XHR/fetch requests to your backend you'll need to configure your backend [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers) to allow the `sentry-trace` and `baggage` headers. The configuration of your servers response headers might look like `"Access-Control-Allow-Headers: sentry-trace"` and `"Access-Control-Allow-Headers: baggage"`, but the configuration depends on your setup. If you don't allow the `sentry-trace` and `baggage` headers, the request might be blocked. +If your frontend and your backend live on different domains (ex. frontend on `https://example.com` and backend on `https://api.example.com`), and the frontend does XHR/fetch requests to your backend, you'll need to configure your backend [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers) headers. + +The backend needs to allow the `sentry-trace` and `baggage` headers. Requests might be blocked if you don't allow the `sentry-trace` and `baggage` headers. + +Your server's response header configuration might look like: `"Access-Control-Allow-Headers: sentry-trace, baggage"`. Your configuration will be specific to your setup. diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx index 4a6c3cb64c30c..46734e7cc0b15 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx @@ -18,3 +18,11 @@ sentry_sdk.init( In this example trace information will be added to all requests to URLs that contain `"https://myproject.org"` or to all ULRs of all sub domains of `otherservice.org` like `https://api.otherservice.org/something/`, `https://payment.otherservice.org/something/` and so on. See `trace_propagation_targets` documentation for more information about this option. + +### Configure CORS Headers + +If your frontend and your backend live on different domains (ex. frontend on `https://example.com` and backend on `https://api.example.com`), and the frontend does XHR/fetch requests to your backend, you'll need to configure your backend [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers) headers. + +The backend needs to allow the `sentry-trace` and `baggage` headers. Requests might be blocked if you don't allow the `sentry-trace` and `baggage` headers. + +Your server's response header configuration might look like: `"Access-Control-Allow-Headers: sentry-trace, baggage"`. Your configuration will be specific to your setup. diff --git a/src/platform-includes/distributed-tracing/other-services/javascript.mdx b/src/platform-includes/distributed-tracing/other-services/javascript.mdx deleted file mode 100644 index eedde11a86718..0000000000000 --- a/src/platform-includes/distributed-tracing/other-services/javascript.mdx +++ /dev/null @@ -1,3 +0,0 @@ -## Setup Your Other Services - -If your frontend project does XHR/fetch requests to your backend you'll need to configure your backend [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers) to allow the `sentry-trace` and `baggage` headers. The configuration of your servers response headers might look like `"Access-Control-Allow-Headers: sentry-trace"` and `"Access-Control-Allow-Headers: baggage"`, but the configuration depends on your setup. If you don't allow the `sentry-trace` and `baggage` headers, the request might be blocked. diff --git a/src/platform-includes/distributed-tracing/other-services/python.mdx b/src/platform-includes/distributed-tracing/other-services/python.mdx index 50299487d24bf..006160e726590 100644 --- a/src/platform-includes/distributed-tracing/other-services/python.mdx +++ b/src/platform-includes/distributed-tracing/other-services/python.mdx @@ -1,9 +1,7 @@ -## Setup Your Other Services +## Set Up Other Services -Setup the Sentry SDK for all your other connected services. Check the Sentry documentation of the languages your connected services are written in if distributed tracing is supported out of the box, or if you need to do some custom instrumentation. +Setup the Sentry SDK for all your other connected services. Check the Sentry documentation of the languages your connected services are written in whether distributed tracing is supported out of the box, or if you need to do some custom instrumentation. Check out the Javascript documentation to learn [how to setup distributed tracing in your frontend](/platforms/javascript/distributed-tracing/instrumentation/automatic-instrumentation/). -### CORS headers - -If your frontend project does XHR/fetch requests to your backend you'll need to configure your backend [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers) to allow the `sentry-trace` and `baggage` headers. The configuration of your servers response headers might look like `"Access-Control-Allow-Headers: sentry-trace"` and `"Access-Control-Allow-Headers: baggage"`, but the configuration depends on your setup. If you don't allow the `sentry-trace` and `baggage` headers, the request might be blocked. +In case your Javascript connects from a differnt domain, you might need to Configure CORS Headers. From 1edd758f4e54c98c7224b6ae479613cef4879add Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Fri, 23 Jun 2023 15:19:11 +0200 Subject: [PATCH 066/116] Wording --- src/platforms/common/distributed-tracing/index.mdx | 6 +++--- src/platforms/common/performance/index.mdx | 2 +- src/platforms/node/guides/express/performance/index.mdx | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/platforms/common/distributed-tracing/index.mdx b/src/platforms/common/distributed-tracing/index.mdx index e1641f908e505..f43f50b28fa19 100644 --- a/src/platforms/common/distributed-tracing/index.mdx +++ b/src/platforms/common/distributed-tracing/index.mdx @@ -11,14 +11,14 @@ notSupported: ## What Is Distributed Tracing? -Applications can consist of multiple components, which are also called services. A web application for example can consist of a frontend, a backend and a microservice. A mobile app can alike constist of the mobile app running on the device and a backend and a microserivce. +Applications can consist of multiple components, which are also called services. A web application for example can consist of a frontend, a backend and a microservice. A mobile app can alike constists of the mobile app running on the device and a backend and a microserivce. When a user triggeres an action in the frontend/app it will call the backend which on its part calls the microservice. So the users action leaves a trace through three services. Adding a unique trace ID to the users actions and passing it on from the frontend/app to the backend and further on to the microservice is called distributed tracing. -This way all the information that is collect on the frontend, the backend and the microservice is associated with one unique trace. Which makes it possible to relate information that was collected on the frontend with information collected in the backend or microservice +This way all the information that is collected on the frontend, the backend and the microservice is correlated via the unique trace ID. You could for example see what UI element was clicked on the frontend that lead to an error in the microservice. This gives you the complete picture of what was happing in your application as a whole, not just what was happening in one service. @@ -33,7 +33,7 @@ There are two headers that are used to propagate tracing information: - `sentry-trace` - `baggage` -For distributed tracing to work make sure that those headers are not blocked or stripped by your proxy servers or firewalls. +Make sure that those headers aren't blocked or stripped by your proxy servers or firewalls to ensure distributed tracing works correctly. diff --git a/src/platforms/common/performance/index.mdx b/src/platforms/common/performance/index.mdx index f64638ceed08e..bcbf45ee96975 100644 --- a/src/platforms/common/performance/index.mdx +++ b/src/platforms/common/performance/index.mdx @@ -108,7 +108,7 @@ If you leave your sample rate at `1.0`, a transaction will be sent every time a ## Connecting Services -If you are also using Performance Monitoring for [JavaScript](/platforms/javascript/performance/), you can connect the frontend and the backend service by enabling [Distributed Tracing](/platforms/javascript/distributed-tracing/). +If you are also using Performance Monitoring for [JavaScript](/platforms/javascript/performance/), you can connect the frontend and the backend service by configuring [Distributed Tracing](/platforms/javascript/distributed-tracing/). diff --git a/src/platforms/node/guides/express/performance/index.mdx b/src/platforms/node/guides/express/performance/index.mdx index 44c91e7053ac0..1a97ebc8331d5 100644 --- a/src/platforms/node/guides/express/performance/index.mdx +++ b/src/platforms/node/guides/express/performance/index.mdx @@ -131,4 +131,4 @@ app.get("/success", function successHandler(req, res) { ## Connecting Services -If you are also using Performance Monitoring for [JavaScript](/platforms/javascript/performance/), you can connect the frontend and the backend service by enabling [Distributed Tracing](/platforms/javascript/distributed-tracing/). +If you are also using Performance Monitoring for [JavaScript](/platforms/javascript/performance/), you can connect the frontend and the backend service by configuring [Distributed Tracing](/platforms/javascript/distributed-tracing/). From 4dacc2f9707f8be29281eafd811d4b11ee296cf4 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Fri, 23 Jun 2023 15:23:31 +0200 Subject: [PATCH 067/116] Removed useless stuff --- .../common/distributed-tracing/index.mdx | 35 ------------------- 1 file changed, 35 deletions(-) diff --git a/src/platforms/common/distributed-tracing/index.mdx b/src/platforms/common/distributed-tracing/index.mdx index f43f50b28fa19..e1b3806758ad2 100644 --- a/src/platforms/common/distributed-tracing/index.mdx +++ b/src/platforms/common/distributed-tracing/index.mdx @@ -35,41 +35,6 @@ There are two headers that are used to propagate tracing information: Make sure that those headers aren't blocked or stripped by your proxy servers or firewalls to ensure distributed tracing works correctly. - - -
- -### `sentry-trace` header - -The `sentry-trace` header is inspired by the `traceparent` header of the [W3C Trace Context](https://www.w3.org/TR/trace-context/#traceparent-header) but without the version. - -`sentry-trace = traceid-spanid-sampled` - -`sampled` is optional. So at a minimum, it's expected: - -`sentry-trace = traceid-spanid` - -Description of the parts: - -- `traceid`: 128 bits encoded in 32 hex chars -- `spanid`: 64 bits encoded in 16 hex chars -- `sampled`: One single (optional) character - - ` ` (no value) = Defer sampling decision - - `0` = Don't sample - - `1` = Sample - -Example: `"771a43a4192642f0b136d5159a501700-1234567890abcdef-1"` - -
- -### `baggage` header - -The [W3C Propagation format for distributed context: Baggage](https://www.w3.org/TR/baggage/) implementing tracing information as URI encoded key-value pairs. - -It contains additional information used by Sentrys distributed tracing. See [Baggage header](https://develop.sentry.dev/sdk/performance/dynamic-sampling-context/#baggage-header) in our developer documentation to learn more. - - - From 3698637af6598f20acba81906f7b6d92bf3b1b5d Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Fri, 23 Jun 2023 15:52:43 +0200 Subject: [PATCH 068/116] Cleanup --- .../common/distributed-tracing/index.mdx | 37 +++---------------- 1 file changed, 5 insertions(+), 32 deletions(-) diff --git a/src/platforms/common/distributed-tracing/index.mdx b/src/platforms/common/distributed-tracing/index.mdx index e1b3806758ad2..a359abe2675db 100644 --- a/src/platforms/common/distributed-tracing/index.mdx +++ b/src/platforms/common/distributed-tracing/index.mdx @@ -9,46 +9,19 @@ notSupported: - javascript.cordova --- -## What Is Distributed Tracing? +Distributed tracing is when associating the same trace information to all data that is gathered in your services (like a web frontend, a mobile app, a backend, and some microservices) during a request. This way all the gathered information during that request is visible in a trace. In Sentry a trace looks like this: -Applications can consist of multiple components, which are also called services. A web application for example can consist of a frontend, a backend and a microservice. A mobile app can alike constists of the mobile app running on the device and a backend and a microserivce. +![A full distributed trace in Sentry](distributed-trace-in-sentry.png) -When a user triggeres an action in the frontend/app it will call the backend which on its part calls the microservice. -So the users action leaves a trace through three services. +The trace gives you the complete picture of what was happing in your application as a whole, not just what was happening in one service. (You can drill down into each service from the trace.) -Adding a unique trace ID to the users actions and passing it on from the frontend/app to the backend and further on to the microservice is called distributed tracing. - -This way all the information that is collected on the frontend, the backend and the microservice is correlated via the unique trace ID. - -You could for example see what UI element was clicked on the frontend that lead to an error in the microservice. This gives you the complete picture of what was happing in your application as a whole, not just what was happening in one service. - -## How Does Distributed Tracing Work in Sentry? - -Sentry SDKs inject tracing information into outgoing requests and extract tracing information from incoming requests. - -![Trace propagation in Sentry SDK](distributed-tracing-trace-propagation.png) - -There are two headers that are used to propagate tracing information: +There are two HTTP headers that are used in Sentry to propagate tracing information between services: - `sentry-trace` - `baggage` -Make sure that those headers aren't blocked or stripped by your proxy servers or firewalls to ensure distributed tracing works correctly. +Make sure that those headers aren't blocked or stripped by your proxy servers, gateways, or firewalls to ensure distributed tracing works correctly. - - From 6bdb0ff983839d9726f53b8b1c3421ff7811d490 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Fri, 23 Jun 2023 15:53:01 +0200 Subject: [PATCH 069/116] Added missing image --- .../distributed-trace-in-sentry.png | Bin 0 -> 25782 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 src/platforms/common/distributed-tracing/distributed-trace-in-sentry.png diff --git a/src/platforms/common/distributed-tracing/distributed-trace-in-sentry.png b/src/platforms/common/distributed-tracing/distributed-trace-in-sentry.png new file mode 100644 index 0000000000000000000000000000000000000000..e46ea6d5c0d463e3ac7ec766b8b1cb7fc60d543a GIT binary patch literal 25782 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 literal 0 HcmV?d00001 From e7cdaf54dee12b524b7e3ccf550f99f4875b41a2 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Fri, 23 Jun 2023 15:59:09 +0200 Subject: [PATCH 070/116] Wording --- src/platforms/common/distributed-tracing/index.mdx | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/platforms/common/distributed-tracing/index.mdx b/src/platforms/common/distributed-tracing/index.mdx index a359abe2675db..fdfed73fdc5d7 100644 --- a/src/platforms/common/distributed-tracing/index.mdx +++ b/src/platforms/common/distributed-tracing/index.mdx @@ -13,6 +13,8 @@ Distributed tracing is when associating the same trace information to all data t ![A full distributed trace in Sentry](distributed-trace-in-sentry.png) +(In this example on `pageload` of a Vue app a request to a Python backend is done. The Python backend then calls the `/api` endpoint in a Ruby microservice.) + The trace gives you the complete picture of what was happing in your application as a whole, not just what was happening in one service. (You can drill down into each service from the trace.) There are two HTTP headers that are used in Sentry to propagate tracing information between services: From f3c741ead15cd2a6fb3a5d303e5e5282bdfa1a35 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Fri, 23 Jun 2023 16:34:30 +0200 Subject: [PATCH 071/116] Fixed links --- .../distributed-tracing/configuration/javascript.mdx | 2 +- src/platform-includes/distributed-tracing/index/javascript.mdx | 2 +- .../automatic-instrumentation-intro/javascript.mdx | 2 +- .../instrumentation/custom-instrumentation/javascript.mdx | 2 +- .../performance/connect-services/javascript.mdx | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/platform-includes/distributed-tracing/configuration/javascript.mdx b/src/platform-includes/distributed-tracing/configuration/javascript.mdx index 12a640adc1816..49f0ed4c5c107 100644 --- a/src/platform-includes/distributed-tracing/configuration/javascript.mdx +++ b/src/platform-includes/distributed-tracing/configuration/javascript.mdx @@ -1,6 +1,6 @@ ## Configuration -All Sentry JavaScript SDKs support distributed tracing out of the box if you add the BrowserTracing integration to your `Sentry.init` option. The Next.js and SvelteKit SDKs already include this integration by default. +All Sentry JavaScript SDKs support distributed tracing out of the box if you add the BrowserTracing integration to your `Sentry.init` option. The [Next.js](/platforms/javascript/guides/nextjs/) and [SvelteKit](/platforms/javascript/guides/sveltekit/) SDKs already include this integration by default. In case your backend lives on a differnt domain, you might need to Configure Backend CORS Headers. diff --git a/src/platform-includes/distributed-tracing/index/javascript.mdx b/src/platform-includes/distributed-tracing/index/javascript.mdx index a9a8ec5f284d9..a31a6f7616cff 100644 --- a/src/platform-includes/distributed-tracing/index/javascript.mdx +++ b/src/platform-includes/distributed-tracing/index/javascript.mdx @@ -1,3 +1,3 @@ -All Sentry JavaScript SDKs support distributed tracing out of the box if you add the BrowserTracing integration to your `Sentry.init` option. The Next.js and SvelteKit SDKs already include this integration by default. +All Sentry JavaScript SDKs support distributed tracing out of the box if you add the BrowserTracing integration to your `Sentry.init` option. The [Next.js](/platforms/javascript/guides/nextjs/) and [SvelteKit](/platforms/javascript/guides/sveltekit/) SDKs already include this integration by default. See Automatic Instrumentation to learn more. diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/javascript.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/javascript.mdx index 4a8d18ae8d8ac..82aff3a17948c 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/javascript.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/javascript.mdx @@ -1,4 +1,4 @@ -All Sentry JavaScript SDKs support distributed tracing out of the box if you add the BrowserTracing integration to your `Sentry.init` option. The Next.js and SvelteKit SDKs already include this integration by default. +All Sentry JavaScript SDKs support distributed tracing out of the box if you add the BrowserTracing integration to your `Sentry.init` option. The [Next.js](/platforms/javascript/guides/nextjs/) and [SvelteKit](/platforms/javascript/guides/sveltekit/) SDKs already include this integration by default. Tracing information sent from the backend via the `sentry-tracing` and `baggage` HTML `meta` tags will be extracted and stored in a transaction that is created at page load. diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx index 71210f4841f22..18049063208ff 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx @@ -10,7 +10,7 @@ then revisit this page and change it to match the new official apis to use. -All Sentry JavaScript SDKs support distributed tracing out of the box if you add the BrowserTracing integration to your `Sentry.init` option. The Next.js and SvelteKit SDKs already include this integration by default. +All Sentry JavaScript SDKs support distributed tracing out of the box if you add the BrowserTracing integration to your `Sentry.init` option. The [Next.js](/platforms/javascript/guides/nextjs/) and [SvelteKit](/platforms/javascript/guides/sveltekit/) SDKs already include this integration by default. If you are using one of the integrations of Frameworks listed above, **you do not need to do anything** for distributed tracing to work! diff --git a/src/platform-includes/performance/connect-services/javascript.mdx b/src/platform-includes/performance/connect-services/javascript.mdx index 4f3573eb52da8..0d5518f164990 100644 --- a/src/platform-includes/performance/connect-services/javascript.mdx +++ b/src/platform-includes/performance/connect-services/javascript.mdx @@ -8,7 +8,7 @@ The `baggage` header was added with version 7 of the Sentry Javascript SDK and i -All Sentry JavaScript SDKs support distributed tracing out of the box if you add the BrowserTracing integration to your `Sentry.init` option. The Next.js and SvelteKit SDKs already include this integration by default. +All Sentry JavaScript SDKs support distributed tracing out of the box if you add the BrowserTracing integration to your `Sentry.init` option. The [Next.js](/platforms/javascript/guides/nextjs/) and [SvelteKit](/platforms/javascript/guides/sveltekit/) SDKs already include this integration by default. The JavaScript SDK will only attach the trace headers to outgoing HTTP requests for which the destination is a substring or regex match to the tracePropagationTargets list. `tracePropagationTargets` was previously called `tracingOrigins`. From 48ce7b935de6d73580641b4026a25195d813197a Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Mon, 26 Jun 2023 11:12:19 +0200 Subject: [PATCH 072/116] Removed unused image --- .../distributed-tracing-trace-propagation.png | Bin 37377 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 src/platforms/common/distributed-tracing/distributed-tracing-trace-propagation.png diff --git a/src/platforms/common/distributed-tracing/distributed-tracing-trace-propagation.png b/src/platforms/common/distributed-tracing/distributed-tracing-trace-propagation.png deleted file mode 100644 index 46b5988a75690b626154b14d61f3d39434267128..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 37377 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 Date: Mon, 26 Jun 2023 13:59:20 +0200 Subject: [PATCH 073/116] Restructuring for redirects to work --- .../configuration/_default.mdx | 1 - .../configuration/javascript.mdx | 11 ------- .../configuration/python.mdx | 22 ------------- .../distributed-tracing/index/_default.mdx | 6 ---- .../distributed-tracing/index/javascript.mdx | 3 -- .../distributed-tracing/index/python.mdx | 3 -- .../other-services/_default.mdx | 1 - .../other-services/python.mdx | 7 ----- .../distributed-trace-in-sentry.png | Bin 25782 -> 0 bytes .../common/distributed-tracing/index.mdx | 29 ------------------ .../instrumentation/index.mdx | 2 +- 11 files changed, 1 insertion(+), 84 deletions(-) delete mode 100644 src/platform-includes/distributed-tracing/configuration/_default.mdx delete mode 100644 src/platform-includes/distributed-tracing/configuration/javascript.mdx delete mode 100644 src/platform-includes/distributed-tracing/configuration/python.mdx delete mode 100644 src/platform-includes/distributed-tracing/index/_default.mdx delete mode 100644 src/platform-includes/distributed-tracing/index/javascript.mdx delete mode 100644 src/platform-includes/distributed-tracing/index/python.mdx delete mode 100644 src/platform-includes/distributed-tracing/other-services/_default.mdx delete mode 100644 src/platform-includes/distributed-tracing/other-services/python.mdx delete mode 100644 src/platforms/common/distributed-tracing/distributed-trace-in-sentry.png delete mode 100644 src/platforms/common/distributed-tracing/index.mdx diff --git a/src/platform-includes/distributed-tracing/configuration/_default.mdx b/src/platform-includes/distributed-tracing/configuration/_default.mdx deleted file mode 100644 index aa8fc28701a99..0000000000000 --- a/src/platform-includes/distributed-tracing/configuration/_default.mdx +++ /dev/null @@ -1 +0,0 @@ - diff --git a/src/platform-includes/distributed-tracing/configuration/javascript.mdx b/src/platform-includes/distributed-tracing/configuration/javascript.mdx deleted file mode 100644 index 49f0ed4c5c107..0000000000000 --- a/src/platform-includes/distributed-tracing/configuration/javascript.mdx +++ /dev/null @@ -1,11 +0,0 @@ -## Configuration - -All Sentry JavaScript SDKs support distributed tracing out of the box if you add the BrowserTracing integration to your `Sentry.init` option. The [Next.js](/platforms/javascript/guides/nextjs/) and [SvelteKit](/platforms/javascript/guides/sveltekit/) SDKs already include this integration by default. - -In case your backend lives on a differnt domain, you might need to Configure Backend CORS Headers. - - - -**You need to have "Performance Monitoring" enabled!** See Set Up Performance on how to enable performance monitoring. - - diff --git a/src/platform-includes/distributed-tracing/configuration/python.mdx b/src/platform-includes/distributed-tracing/configuration/python.mdx deleted file mode 100644 index 3169d3b5e2cd1..0000000000000 --- a/src/platform-includes/distributed-tracing/configuration/python.mdx +++ /dev/null @@ -1,22 +0,0 @@ -## Configuration - -Distributed tracing works out of the box for the following Python frameworks: Django, FastAPI, Flask, Bottle, Falcon, Pyramid, Quart, Starlette, Tornado. - -If you have a vanilla Python project or use an unsupported framework you need to implement Custom Instrumentation. - - - -In Python SDKs version `1.25.x` and below you need to have "Performance Monitoring" enabled for distributed tracing to work. Learn more in Set Up Performance. - - - - diff --git a/src/platform-includes/distributed-tracing/index/_default.mdx b/src/platform-includes/distributed-tracing/index/_default.mdx deleted file mode 100644 index ea0b160485187..0000000000000 --- a/src/platform-includes/distributed-tracing/index/_default.mdx +++ /dev/null @@ -1,6 +0,0 @@ -# INDEX DEFAULT - - - Please refer to tracing with and without performance activated and delete this - note and its headline afterwards. - diff --git a/src/platform-includes/distributed-tracing/index/javascript.mdx b/src/platform-includes/distributed-tracing/index/javascript.mdx deleted file mode 100644 index a31a6f7616cff..0000000000000 --- a/src/platform-includes/distributed-tracing/index/javascript.mdx +++ /dev/null @@ -1,3 +0,0 @@ -All Sentry JavaScript SDKs support distributed tracing out of the box if you add the BrowserTracing integration to your `Sentry.init` option. The [Next.js](/platforms/javascript/guides/nextjs/) and [SvelteKit](/platforms/javascript/guides/sveltekit/) SDKs already include this integration by default. - -See Automatic Instrumentation to learn more. diff --git a/src/platform-includes/distributed-tracing/index/python.mdx b/src/platform-includes/distributed-tracing/index/python.mdx deleted file mode 100644 index 7eec879ccab9e..0000000000000 --- a/src/platform-includes/distributed-tracing/index/python.mdx +++ /dev/null @@ -1,3 +0,0 @@ -Distributed tracing works out of the box for the following frameworks: [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/), [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/), [Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/), [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/), [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/), [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/), [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/), [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/). - -If you have a vanilla Python project or use an unsupported framework you need to implement Custom Instrumentation. diff --git a/src/platform-includes/distributed-tracing/other-services/_default.mdx b/src/platform-includes/distributed-tracing/other-services/_default.mdx deleted file mode 100644 index 01e70a488d2ab..0000000000000 --- a/src/platform-includes/distributed-tracing/other-services/_default.mdx +++ /dev/null @@ -1 +0,0 @@ - diff --git a/src/platform-includes/distributed-tracing/other-services/python.mdx b/src/platform-includes/distributed-tracing/other-services/python.mdx deleted file mode 100644 index 006160e726590..0000000000000 --- a/src/platform-includes/distributed-tracing/other-services/python.mdx +++ /dev/null @@ -1,7 +0,0 @@ -## Set Up Other Services - -Setup the Sentry SDK for all your other connected services. Check the Sentry documentation of the languages your connected services are written in whether distributed tracing is supported out of the box, or if you need to do some custom instrumentation. - -Check out the Javascript documentation to learn [how to setup distributed tracing in your frontend](/platforms/javascript/distributed-tracing/instrumentation/automatic-instrumentation/). - -In case your Javascript connects from a differnt domain, you might need to Configure CORS Headers. diff --git a/src/platforms/common/distributed-tracing/distributed-trace-in-sentry.png b/src/platforms/common/distributed-tracing/distributed-trace-in-sentry.png deleted file mode 100644 index e46ea6d5c0d463e3ac7ec766b8b1cb7fc60d543a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 25782 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 diff --git a/src/platforms/common/distributed-tracing/index.mdx b/src/platforms/common/distributed-tracing/index.mdx deleted file mode 100644 index fdfed73fdc5d7..0000000000000 --- a/src/platforms/common/distributed-tracing/index.mdx +++ /dev/null @@ -1,29 +0,0 @@ ---- -title: Distributed Tracing -sidebar_order: 40 -description: "Learn how to connect frontend and backend transactions." -supported: - - javascript - - python -notSupported: - - javascript.cordova ---- - -Distributed tracing is when associating the same trace information to all data that is gathered in your services (like a web frontend, a mobile app, a backend, and some microservices) during a request. This way all the gathered information during that request is visible in a trace. In Sentry a trace looks like this: - -![A full distributed trace in Sentry](distributed-trace-in-sentry.png) - -(In this example on `pageload` of a Vue app a request to a Python backend is done. The Python backend then calls the `/api` endpoint in a Ruby microservice.) - -The trace gives you the complete picture of what was happing in your application as a whole, not just what was happening in one service. (You can drill down into each service from the trace.) - -There are two HTTP headers that are used in Sentry to propagate tracing information between services: - -- `sentry-trace` -- `baggage` - -Make sure that those headers aren't blocked or stripped by your proxy servers, gateways, or firewalls to ensure distributed tracing works correctly. - - - - diff --git a/src/platforms/common/distributed-tracing/instrumentation/index.mdx b/src/platforms/common/distributed-tracing/instrumentation/index.mdx index 766429d4c7ed3..05e12cd9557d4 100644 --- a/src/platforms/common/distributed-tracing/instrumentation/index.mdx +++ b/src/platforms/common/distributed-tracing/instrumentation/index.mdx @@ -9,4 +9,4 @@ notSupported: - javascript.cordova --- - + From 0c9d018f1e62f5949ee4399e748d993279c67cf8 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Mon, 26 Jun 2023 13:59:27 +0200 Subject: [PATCH 074/116] Added missing files --- .../instrumentation/index/_default.mdx | 6 ++++ .../instrumentation/index/javascript.mdx | 3 ++ .../instrumentation/index/python.mdx | 3 ++ .../_default.mdx | 1 + .../javascript.mdx | 11 +++++++ .../python.mdx | 22 ++++++++++++++ .../_default.mdx | 14 +++++++++ .../distributed-trace-in-sentry.png | Bin 0 -> 25782 bytes .../_default.mdx | 1 + .../python.mdx | 7 +++++ .../common/distributed-tracing/index.mdx | 28 ++++++++++++++++++ .../common/distributed-tracing/index.mdx | 26 ++++++++++++++++ 12 files changed, 122 insertions(+) create mode 100644 src/platform-includes/distributed-tracing/instrumentation/index/_default.mdx create mode 100644 src/platform-includes/distributed-tracing/instrumentation/index/javascript.mdx create mode 100644 src/platform-includes/distributed-tracing/instrumentation/index/python.mdx create mode 100644 src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/_default.mdx create mode 100644 src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/javascript.mdx create mode 100644 src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/python.mdx create mode 100644 src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx create mode 100644 src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/distributed-trace-in-sentry.png create mode 100644 src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/_default.mdx create mode 100644 src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/python.mdx create mode 100644 src/platforms/javascript/common/distributed-tracing/index.mdx create mode 100644 src/platforms/python/common/distributed-tracing/index.mdx diff --git a/src/platform-includes/distributed-tracing/instrumentation/index/_default.mdx b/src/platform-includes/distributed-tracing/instrumentation/index/_default.mdx new file mode 100644 index 0000000000000..ea0b160485187 --- /dev/null +++ b/src/platform-includes/distributed-tracing/instrumentation/index/_default.mdx @@ -0,0 +1,6 @@ +# INDEX DEFAULT + + + Please refer to tracing with and without performance activated and delete this + note and its headline afterwards. + diff --git a/src/platform-includes/distributed-tracing/instrumentation/index/javascript.mdx b/src/platform-includes/distributed-tracing/instrumentation/index/javascript.mdx new file mode 100644 index 0000000000000..a31a6f7616cff --- /dev/null +++ b/src/platform-includes/distributed-tracing/instrumentation/index/javascript.mdx @@ -0,0 +1,3 @@ +All Sentry JavaScript SDKs support distributed tracing out of the box if you add the BrowserTracing integration to your `Sentry.init` option. The [Next.js](/platforms/javascript/guides/nextjs/) and [SvelteKit](/platforms/javascript/guides/sveltekit/) SDKs already include this integration by default. + +See Automatic Instrumentation to learn more. diff --git a/src/platform-includes/distributed-tracing/instrumentation/index/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/index/python.mdx new file mode 100644 index 0000000000000..7eec879ccab9e --- /dev/null +++ b/src/platform-includes/distributed-tracing/instrumentation/index/python.mdx @@ -0,0 +1,3 @@ +Distributed tracing works out of the box for the following frameworks: [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/), [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/), [Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/), [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/), [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/), [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/), [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/), [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/). + +If you have a vanilla Python project or use an unsupported framework you need to implement Custom Instrumentation. diff --git a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/_default.mdx b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/_default.mdx new file mode 100644 index 0000000000000..72a07ade5e371 --- /dev/null +++ b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/_default.mdx @@ -0,0 +1 @@ + diff --git a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/javascript.mdx b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/javascript.mdx new file mode 100644 index 0000000000000..49f0ed4c5c107 --- /dev/null +++ b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/javascript.mdx @@ -0,0 +1,11 @@ +## Configuration + +All Sentry JavaScript SDKs support distributed tracing out of the box if you add the BrowserTracing integration to your `Sentry.init` option. The [Next.js](/platforms/javascript/guides/nextjs/) and [SvelteKit](/platforms/javascript/guides/sveltekit/) SDKs already include this integration by default. + +In case your backend lives on a differnt domain, you might need to Configure Backend CORS Headers. + + + +**You need to have "Performance Monitoring" enabled!** See Set Up Performance on how to enable performance monitoring. + + diff --git a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/python.mdx b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/python.mdx new file mode 100644 index 0000000000000..3169d3b5e2cd1 --- /dev/null +++ b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/python.mdx @@ -0,0 +1,22 @@ +## Configuration + +Distributed tracing works out of the box for the following Python frameworks: Django, FastAPI, Flask, Bottle, Falcon, Pyramid, Quart, Starlette, Tornado. + +If you have a vanilla Python project or use an unsupported framework you need to implement Custom Instrumentation. + + + +In Python SDKs version `1.25.x` and below you need to have "Performance Monitoring" enabled for distributed tracing to work. Learn more in Set Up Performance. + + + + diff --git a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx new file mode 100644 index 0000000000000..6cbf9d6d14ecc --- /dev/null +++ b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx @@ -0,0 +1,14 @@ +Distributed tracing is when associating the same trace information to all data that is gathered in your services (like a web frontend, a mobile app, a backend, and some microservices) during a request. This way all the gathered information during that request is visible in a trace. In Sentry a trace looks like this: + +![A full distributed trace in Sentry](distributed-trace-in-sentry.png) + +(In this example on `pageload` of a Vue app a request to a Python backend is done. The Python backend then calls the `/api` endpoint in a Ruby microservice.) + +The trace gives you the complete picture of what was happing in your application as a whole, not just what was happening in one service. (You can drill down into each service from the trace.) + +There are two HTTP headers that are used in Sentry to propagate tracing information between services: + +- `sentry-trace` +- `baggage` + +Make sure that those headers are allow listed in your CORS setup as well as they aren't blocked or stripped by your proxy servers, gateways, or firewalls to ensure distributed tracing works correctly. diff --git a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/distributed-trace-in-sentry.png b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/distributed-trace-in-sentry.png new file mode 100644 index 0000000000000000000000000000000000000000..e46ea6d5c0d463e3ac7ec766b8b1cb7fc60d543a GIT binary patch literal 25782 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 literal 0 HcmV?d00001 diff --git a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/_default.mdx b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/_default.mdx new file mode 100644 index 0000000000000..30b19be3bdcb8 --- /dev/null +++ b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/_default.mdx @@ -0,0 +1 @@ + diff --git a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/python.mdx b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/python.mdx new file mode 100644 index 0000000000000..006160e726590 --- /dev/null +++ b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/python.mdx @@ -0,0 +1,7 @@ +## Set Up Other Services + +Setup the Sentry SDK for all your other connected services. Check the Sentry documentation of the languages your connected services are written in whether distributed tracing is supported out of the box, or if you need to do some custom instrumentation. + +Check out the Javascript documentation to learn [how to setup distributed tracing in your frontend](/platforms/javascript/distributed-tracing/instrumentation/automatic-instrumentation/). + +In case your Javascript connects from a differnt domain, you might need to Configure CORS Headers. diff --git a/src/platforms/javascript/common/distributed-tracing/index.mdx b/src/platforms/javascript/common/distributed-tracing/index.mdx new file mode 100644 index 0000000000000..a23fda7108ed7 --- /dev/null +++ b/src/platforms/javascript/common/distributed-tracing/index.mdx @@ -0,0 +1,28 @@ +--- +title: Distributed Tracing +sidebar_order: 40 +description: "Learn how to connect frontend and backend transactions." +redirect_from: + - /platforms/javascript/performance/connect-services/ + - /platforms/javascript/guides/angular/performance/connect-services/ + - /platforms/javascript/guides/capacitor/performance/connect-services/ + - /platforms/javascript/guides/cordova/performance/connect-services/ + - /platforms/javascript/guides/electron/performance/connect-services/ + - /platforms/javascript/guides/ember/performance/connect-services/ + - /platforms/javascript/guides/gatsby/performance/connect-services/ + - /platforms/javascript/guides/nextjs/performance/connect-services/ + - /platforms/javascript/guides/react/performance/connect-services/ + - /platforms/javascript/guides/remix/performance/connect-services/ + - /platforms/javascript/guides/svelte/performance/connect-services/ + - /platforms/javascript/guides/sveltekit/performance/connect-services/ + - /platforms/javascript/guides/vue/performance/connect-services/ + - /platforms/javascript/guides/wasm/performance/connect-services/ +notSupported: + - javascript.cordova +--- + + + + + + diff --git a/src/platforms/python/common/distributed-tracing/index.mdx b/src/platforms/python/common/distributed-tracing/index.mdx new file mode 100644 index 0000000000000..3c9c41d070a6b --- /dev/null +++ b/src/platforms/python/common/distributed-tracing/index.mdx @@ -0,0 +1,26 @@ +--- +title: Distributed Tracing +sidebar_order: 40 +description: "Learn how to connect frontend and backend transactions." +redirect_from: + - /platforms/python/performance/connect-services/ + - /platforms/python/guides/angular/performance/connect-services/ + - /platforms/python/guides/capacitor/performance/connect-services/ + - /platforms/python/guides/cordova/performance/connect-services/ + - /platforms/python/guides/electron/performance/connect-services/ + - /platforms/python/guides/ember/performance/connect-services/ + - /platforms/python/guides/gatsby/performance/connect-services/ + - /platforms/python/guides/nextjs/performance/connect-services/ + - /platforms/python/guides/react/performance/connect-services/ + - /platforms/python/guides/remix/performance/connect-services/ + - /platforms/python/guides/svelte/performance/connect-services/ + - /platforms/python/guides/sveltekit/performance/connect-services/ + - /platforms/python/guides/vue/performance/connect-services/ + - /platforms/python/guides/wasm/performance/connect-services/ +--- + + + + + + From 9aac7970ce7cffa3d9eebff845ea045f989504ee Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Mon, 26 Jun 2023 14:04:38 +0200 Subject: [PATCH 075/116] Fixed python redirects --- .../common/distributed-tracing/index.mdx | 35 ++++++++++++------- 1 file changed, 22 insertions(+), 13 deletions(-) diff --git a/src/platforms/python/common/distributed-tracing/index.mdx b/src/platforms/python/common/distributed-tracing/index.mdx index 3c9c41d070a6b..d10eda55d6ee1 100644 --- a/src/platforms/python/common/distributed-tracing/index.mdx +++ b/src/platforms/python/common/distributed-tracing/index.mdx @@ -4,19 +4,28 @@ sidebar_order: 40 description: "Learn how to connect frontend and backend transactions." redirect_from: - /platforms/python/performance/connect-services/ - - /platforms/python/guides/angular/performance/connect-services/ - - /platforms/python/guides/capacitor/performance/connect-services/ - - /platforms/python/guides/cordova/performance/connect-services/ - - /platforms/python/guides/electron/performance/connect-services/ - - /platforms/python/guides/ember/performance/connect-services/ - - /platforms/python/guides/gatsby/performance/connect-services/ - - /platforms/python/guides/nextjs/performance/connect-services/ - - /platforms/python/guides/react/performance/connect-services/ - - /platforms/python/guides/remix/performance/connect-services/ - - /platforms/python/guides/svelte/performance/connect-services/ - - /platforms/python/guides/sveltekit/performance/connect-services/ - - /platforms/python/guides/vue/performance/connect-services/ - - /platforms/python/guides/wasm/performance/connect-services/ + - /platforms/python/guides/aiohttp/performance/connect-services/ + - /platforms/python/guides/airflow/performance/connect-services/ + - /platforms/python/guides/arq/performance/connect-services/ + - /platforms/python/guides/aws-lambda/performance/connect-services/ + - /platforms/python/guides/bottle/performance/connect-services/ + - /platforms/python/guides/celery/performance/connect-services/ + - /platforms/python/guides/chalice/performance/connect-services/ + - /platforms/python/guides/django/performance/connect-services/ + - /platforms/python/guides/falcon/performance/connect-services/ + - /platforms/python/guides/fastapi/performance/connect-services/ + - /platforms/python/guides/flask/performance/connect-services/ + - /platforms/python/guides/gcp-function/performance/connect-services/ + - /platforms/python/guides/logging/performance/connect-services/ + - /platforms/python/guides/pyramid/performance/connect-services/ + - /platforms/python/guides/pyspark/performance/connect-services/ + - /platforms/python/guides/quart/performance/connect-services/ + - /platforms/python/guides/rq/performance/connect-services/ + - /platforms/python/guides/sanic/performance/connect-services/ + - /platforms/python/guides/serverless/performance/connect-services/ + - /platforms/python/guides/starlette/performance/connect-services/ + - /platforms/python/guides/tornado/performance/connect-services/ + - /platforms/python/guides/tryton/performance/connect-services/ --- From fd1afa00e6c80c0f270dfc1344beb6a4be74792e Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Wed, 28 Jun 2023 11:13:45 +0200 Subject: [PATCH 076/116] Update src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx Co-authored-by: Shana Matthews --- .../set-up-distributed-tracing-index/_default.mdx | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx index 6cbf9d6d14ecc..4842b37a17e45 100644 --- a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx +++ b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx @@ -1,4 +1,8 @@ -Distributed tracing is when associating the same trace information to all data that is gathered in your services (like a web frontend, a mobile app, a backend, and some microservices) during a request. This way all the gathered information during that request is visible in a trace. In Sentry a trace looks like this: +Distributed tracing allows you to collect trace data across services. For example, with distributed tracing you can collect traces that contain data from requests that have passed through your web frontend, mobile app, backend, and microservices. + +By following requests across service boundaries, distributed tracing can help you understand what happens across your entire application, in addition to seeing details for each service. + +Here's an example showing a distributed trace in Sentry: ![A full distributed trace in Sentry](distributed-trace-in-sentry.png) From 70fb1073eb753f0b90747d1c50895d06ed5830d9 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Wed, 28 Jun 2023 11:14:03 +0200 Subject: [PATCH 077/116] Update src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx Co-authored-by: Shana Matthews --- .../set-up-distributed-tracing-index/_default.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx index 4842b37a17e45..d48b874e2d73c 100644 --- a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx +++ b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx @@ -6,7 +6,7 @@ Here's an example showing a distributed trace in Sentry: ![A full distributed trace in Sentry](distributed-trace-in-sentry.png) -(In this example on `pageload` of a Vue app a request to a Python backend is done. The Python backend then calls the `/api` endpoint in a Ruby microservice.) +This distributed trace shows a Vue app's `pageload` making a request to a Python backend, which then calls the `/api` endpoint of a Ruby microservice. The trace gives you the complete picture of what was happing in your application as a whole, not just what was happening in one service. (You can drill down into each service from the trace.) From 10cdaed1e3416c8c5c70278188c9014bd10276ce Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Wed, 28 Jun 2023 11:14:36 +0200 Subject: [PATCH 078/116] Update src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx Co-authored-by: Shana Matthews --- .../set-up-distributed-tracing-index/_default.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx index d48b874e2d73c..69e9550da3c7a 100644 --- a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx +++ b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx @@ -10,7 +10,7 @@ This distributed trace shows a Vue app's `pageload` making a request to a Python The trace gives you the complete picture of what was happing in your application as a whole, not just what was happening in one service. (You can drill down into each service from the trace.) -There are two HTTP headers that are used in Sentry to propagate tracing information between services: +Sentry uses two HTTP headers to propagate tracing information between services: - `sentry-trace` - `baggage` From 2b6bb57938dc94d440ff5a889bb49d75ffc6cd8f Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Wed, 28 Jun 2023 11:14:57 +0200 Subject: [PATCH 079/116] Update src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx Co-authored-by: Shana Matthews --- .../set-up-distributed-tracing-index/_default.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx index 69e9550da3c7a..d277ea7880c24 100644 --- a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx +++ b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx @@ -15,4 +15,4 @@ Sentry uses two HTTP headers to propagate tracing information between services: - `sentry-trace` - `baggage` -Make sure that those headers are allow listed in your CORS setup as well as they aren't blocked or stripped by your proxy servers, gateways, or firewalls to ensure distributed tracing works correctly. +To ensure distributed tracing works correctly, you must add these headers to your CORS allowlist and ensure they aren't blocked or stripped by your proxy servers, gateways, or firewalls. From e9a72764374a6f9180613addac94f910307a85f4 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Wed, 28 Jun 2023 11:17:45 +0200 Subject: [PATCH 080/116] Update src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx Co-authored-by: Shana Matthews --- .../instrumentation/custom-instrumentation/javascript.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx index 18049063208ff..8e995d685e130 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx @@ -57,7 +57,7 @@ const transactionContext = { const pageLoadTransaction = startTransaction(hub, transactionContext); ``` -In this example we create a new transaction, that is attached to the trace that was specified in the information in the `sentry-trace` and `baggage` HTML `meta` tags. +In this example, we create a new transaction that is attached to the trace specified in the `sentry-trace` and `baggage` HTML `meta` tags. ## Inject Tracing Information to Outgoing Requests From 053561923d54b0e44f20640759cbd91181ae5b67 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Wed, 28 Jun 2023 11:18:22 +0200 Subject: [PATCH 081/116] Update src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx Co-authored-by: Shana Matthews --- .../instrumentation/custom-instrumentation/javascript.mdx | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx index 8e995d685e130..a7e5b0acbf8ff 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx @@ -61,7 +61,9 @@ In this example, we create a new transaction that is attached to the trace speci ## Inject Tracing Information to Outgoing Requests -On outgoing XHR/fetch requests you have to add the two headers `sentry-trace` and `baggage` that you extracted and stored in the `pageLoadTransaction` earlier. +For distributed tracing to work, the two headers that you extracted and stored in the `pageLoadTransaction`, `sentry-trace` and `baggage`, must be added to outgoing XHR/fetch requests. + +Here's an example of how to collect and inject this tracing information to outgoing requests: If you are do outgoing requests in another way you can generate the tracing information like follows: From 9b2cf6196164e28f1066a4c9dfcb39470573bf92 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Wed, 28 Jun 2023 11:19:02 +0200 Subject: [PATCH 082/116] Update src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx Co-authored-by: Shana Matthews --- .../instrumentation/custom-instrumentation/javascript.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx index a7e5b0acbf8ff..951569d3831d7 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx @@ -89,7 +89,7 @@ fetch("https://example.com", { }); ``` -Now tracing information is propagated to the project running at `https://example.com`. If it has a Sentry SDK running, it will extract and save the tracing information for later use. +In this example, tracing information is propagated to the project running at `https://example.com`. If this project uses a Sentry SDK, it will extract and save the tracing information for later use. The two services are now connected with your custom distributed tracing implementation. From 8e46039bd6af78868c01f48f77560a394afd98d9 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Wed, 28 Jun 2023 11:21:29 +0200 Subject: [PATCH 083/116] Update src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx Co-authored-by: Shana Matthews --- .../instrumentation/custom-instrumentation/javascript.mdx | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx index 951569d3831d7..cd0cf2a564a02 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx @@ -27,11 +27,11 @@ To learn more see also: `trace_propagation_targets` documentation for more information about this option. From e8f8055b561047d3b49820c8d030b8a865d023ff Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Wed, 28 Jun 2023 11:26:23 +0200 Subject: [PATCH 085/116] Update src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx Co-authored-by: Shana Matthews --- .../automatic-instrumentation-configuration/javascript.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx index 402790820f9ec..3498d8850cf68 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx @@ -17,7 +17,7 @@ Sentry.init({ In this example, trace information will be added to outgoing XHR/fetch requests to `localhost` and URLs starting with `https://api.example.com`. -See docs on `tracePropagationTargets` to learn more. +See Tracing Options docs for more information about the `trace_propagation_targets` option. ### Configure Backend CORS Headers From 114bdf71d7c72beb6bd3e02d5656df6dfe8dc8d2 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Wed, 28 Jun 2023 11:27:00 +0200 Subject: [PATCH 086/116] Update src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx Co-authored-by: Shana Matthews --- .../automatic-instrumentation-configuration/javascript.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx index 3498d8850cf68..e8acc519ed30a 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx @@ -21,7 +21,7 @@ See Tracing ### Configure Backend CORS Headers -If your frontend and your backend live on different domains (ex. frontend on `https://example.com` and backend on `https://api.example.com`), and the frontend does XHR/fetch requests to your backend, you'll need to configure your backend [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers) headers. +If your backend is hosted on a different domain than your frontend, for example, your frontend on is `https://example.com` and your backend is on `https://api.example.com`, and the frontend does XHR/fetch requests to your backend, you'll need to configure your backend [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers) headers to ensure requests aren't blocked. The backend needs to allow the `sentry-trace` and `baggage` headers. Requests might be blocked if you don't allow the `sentry-trace` and `baggage` headers. From ba5197dad0e5112433830aebaacde6f5da4deec7 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Wed, 28 Jun 2023 11:27:18 +0200 Subject: [PATCH 087/116] Update src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx Co-authored-by: Shana Matthews --- .../automatic-instrumentation-configuration/javascript.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx index e8acc519ed30a..dbeb0c963fa43 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx @@ -23,6 +23,6 @@ See Tracing If your backend is hosted on a different domain than your frontend, for example, your frontend on is `https://example.com` and your backend is on `https://api.example.com`, and the frontend does XHR/fetch requests to your backend, you'll need to configure your backend [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers) headers to ensure requests aren't blocked. -The backend needs to allow the `sentry-trace` and `baggage` headers. Requests might be blocked if you don't allow the `sentry-trace` and `baggage` headers. +Configure your backend CORS to allow the `sentry-trace` and `baggage` headers. Your server's response header configuration might look like: `"Access-Control-Allow-Headers: sentry-trace, baggage"`. Your configuration will be specific to your setup. From 3fb2d6d9adbd2556fcac70a48ec3add60122f6d3 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Wed, 28 Jun 2023 11:27:36 +0200 Subject: [PATCH 088/116] Update src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx Co-authored-by: Shana Matthews --- .../automatic-instrumentation-configuration/python.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx index c35fd93d99b6f..a7f73ad24b96d 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx @@ -1,6 +1,6 @@ ## Configuration -By default trace information (`sentry-trace` and `baggage` headers) will be added to **all** outgoing HTTP requests. If you want to limit to what URLs the trace information should be added you can specify an `trace_propagation_targets` option: +By default, trace information (`sentry-trace` and `baggage` headers) will be added to all outgoing HTTP requests. If you want to limit to the URLs where trace information is added, you can specify a `trace_propagation_targets` option: ```python import sentry_sdk From e29907d8759eb0b41101dcae3375c3d101b29c27 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Wed, 28 Jun 2023 11:28:03 +0200 Subject: [PATCH 089/116] Update src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx Co-authored-by: Shana Matthews --- .../automatic-instrumentation-configuration/python.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx index a7f73ad24b96d..3cdab2c755b4d 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx @@ -17,7 +17,7 @@ sentry_sdk.init( In the example above, trace information will be added to all requests to URLs that contain `"https://myproject.org"` and to all URLs of all sub domains of `otherservice.org` like `https://api.otherservice.org/something/` or `https://payment.otherservice.org/something/`. -See `trace_propagation_targets` documentation for more information about this option. +See Tracing Options docs for more information about the `trace_propagation_targets` option. ### Configure CORS Headers From 0e80afe2f53e6bed83ff921a98fc4068181cb0a6 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Wed, 28 Jun 2023 11:28:18 +0200 Subject: [PATCH 090/116] Update src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx Co-authored-by: Shana Matthews --- .../automatic-instrumentation-configuration/python.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx index 3cdab2c755b4d..ed90cbfd2191e 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx @@ -21,7 +21,7 @@ See Tracing ### Configure CORS Headers -If your frontend and your backend live on different domains (ex. frontend on `https://example.com` and backend on `https://api.example.com`), and the frontend does XHR/fetch requests to your backend, you'll need to configure your backend [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers) headers. +If your backend is hosted on a different domain than your frontend, for example, your frontend on is `https://example.com` and your backend is on `https://api.example.com`, and the frontend does XHR/fetch requests to your backend, you'll need to configure your backend [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers) headers to ensure requests aren't blocked. The backend needs to allow the `sentry-trace` and `baggage` headers. Requests might be blocked if you don't allow the `sentry-trace` and `baggage` headers. From 2f5a890365decdcdc862be5576e1caf01e4187fd Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Wed, 28 Jun 2023 11:28:34 +0200 Subject: [PATCH 091/116] Update src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx Co-authored-by: Shana Matthews --- .../automatic-instrumentation-configuration/python.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx index ed90cbfd2191e..d3d184c7f2b1d 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx @@ -23,6 +23,6 @@ See Tracing If your backend is hosted on a different domain than your frontend, for example, your frontend on is `https://example.com` and your backend is on `https://api.example.com`, and the frontend does XHR/fetch requests to your backend, you'll need to configure your backend [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers) headers to ensure requests aren't blocked. -The backend needs to allow the `sentry-trace` and `baggage` headers. Requests might be blocked if you don't allow the `sentry-trace` and `baggage` headers. +Configure your backend CORS to allow the `sentry-trace` and `baggage` headers. Your server's response header configuration might look like: `"Access-Control-Allow-Headers: sentry-trace, baggage"`. Your configuration will be specific to your setup. From f8907be9f3d4e47cb9d112e24e95f1539c444137 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Wed, 28 Jun 2023 11:29:01 +0200 Subject: [PATCH 092/116] Update src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/javascript.mdx Co-authored-by: Shana Matthews --- .../automatic-instrumentation-intro/javascript.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/javascript.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/javascript.mdx index 82aff3a17948c..f926753b078f8 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/javascript.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/javascript.mdx @@ -1,4 +1,4 @@ -All Sentry JavaScript SDKs support distributed tracing out of the box if you add the BrowserTracing integration to your `Sentry.init` option. The [Next.js](/platforms/javascript/guides/nextjs/) and [SvelteKit](/platforms/javascript/guides/sveltekit/) SDKs already include this integration by default. +To enable distributed tracing, add the `BrowserTracing` integration to your `Sentry.init` options, as described in the Performance Automatic Instrumentation docs. The [Next.js](/platforms/javascript/guides/nextjs/) and [SvelteKit](/platforms/javascript/guides/sveltekit/) SDKs include this integration by default. Tracing information sent from the backend via the `sentry-tracing` and `baggage` HTML `meta` tags will be extracted and stored in a transaction that is created at page load. From 1401b2eb6f3925f5517f1272cd5386ff91c9a94a Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Wed, 28 Jun 2023 11:29:25 +0200 Subject: [PATCH 093/116] Update src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.bottle.mdx Co-authored-by: Shana Matthews --- .../automatic-instrumentation-intro/python.bottle.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.bottle.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.bottle.mdx index a07cc147ae7fc..0d3788a889c19 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.bottle.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.bottle.mdx @@ -1,4 +1,4 @@ -If you run a Bottle project **distributed tracing works out of the box**. +There's no additional set up needed to use distributed tracing with Bottle projects. If requests to your Bottle project include the `sentry-trace` and `baggage` headers they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. From 2c9a20031a0d6556f238fda358eea4bb171432b5 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Wed, 28 Jun 2023 11:29:50 +0200 Subject: [PATCH 094/116] Update src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.bottle.mdx Co-authored-by: Shana Matthews --- .../automatic-instrumentation-intro/python.bottle.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.bottle.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.bottle.mdx index 0d3788a889c19..569c1ddfda01a 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.bottle.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.bottle.mdx @@ -1,6 +1,6 @@ There's no additional set up needed to use distributed tracing with Bottle projects. -If requests to your Bottle project include the `sentry-trace` and `baggage` headers they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. +If requests to your Bottle project include the `sentry-trace` and `baggage` headers, they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Bottle project. You need to initialize the Sentry SDK before your app has been initialized and you are good to go: From 0d39254d39882a0c843eb72766c6969e21cd2ce5 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Wed, 28 Jun 2023 11:30:11 +0200 Subject: [PATCH 095/116] Update src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.bottle.mdx Co-authored-by: Shana Matthews --- .../automatic-instrumentation-intro/python.bottle.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.bottle.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.bottle.mdx index 569c1ddfda01a..375ab31e4593b 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.bottle.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.bottle.mdx @@ -2,7 +2,7 @@ There's no additional set up needed to use distributed tracing with Bottle proje If requests to your Bottle project include the `sentry-trace` and `baggage` headers, they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Bottle project. -You need to initialize the Sentry SDK before your app has been initialized and you are good to go: +Make sure you initialize the Sentry SDK before your app: ```python from bottle import Bottle From 00eb45ba848ce152f34aca07d85d57e6a97a6fd4 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Wed, 28 Jun 2023 11:30:28 +0200 Subject: [PATCH 096/116] Update src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.django.mdx Co-authored-by: Shana Matthews --- .../automatic-instrumentation-intro/python.django.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.django.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.django.mdx index 5d7e3acdb097b..b67978a168333 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.django.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.django.mdx @@ -1,4 +1,4 @@ -If you run a Django project **distributed tracing works out of the box**. +There's no additional set up needed to use distributed tracing with Django projects. If requests to your Django project include the `sentry-trace` and `baggage` headers they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. From 89999def323f56d594e1bcdf8958c8747cbc997f Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Wed, 28 Jun 2023 11:41:05 +0200 Subject: [PATCH 097/116] Apply suggestions from code review Co-authored-by: Shana Matthews --- .../python.django.mdx | 4 +-- .../python.falcon.mdx | 6 ++-- .../python.fastapi.mdx | 6 ++-- .../python.flask.mdx | 6 ++-- .../python.mdx | 4 +-- .../python.pyramid.mdx | 6 ++-- .../python.quart.mdx | 6 ++-- .../python.starlette.mdx | 6 ++-- .../python.tornado.mdx | 6 ++-- .../python.mdx | 2 +- .../custom-instrumentation/javascript.mdx | 10 +++--- .../custom-instrumentation/python.mdx | 36 ++++++++----------- .../instrumentation/index/javascript.mdx | 2 +- .../instrumentation/index/python.mdx | 2 +- .../javascript.mdx | 6 ++-- .../python.mdx | 2 +- .../python.mdx | 4 +-- .../connect-services/javascript.mdx | 2 +- 18 files changed, 55 insertions(+), 61 deletions(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.django.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.django.mdx index b67978a168333..1072d30600305 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.django.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.django.mdx @@ -1,8 +1,8 @@ There's no additional set up needed to use distributed tracing with Django projects. -If requests to your Django project include the `sentry-trace` and `baggage` headers they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. +If requests to your Django project include the `sentry-trace` and `baggage` headers, they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. -You need to initialize the Sentry SDK in your `settings.py` file and you are good to go: +Make sure you initialize the Sentry SDK in your `settings.py` file: ```python import sentry_sdk diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.falcon.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.falcon.mdx index 2145f5d36eeab..eec6f68ee301f 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.falcon.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.falcon.mdx @@ -1,8 +1,8 @@ -If you run a Falcon project **distributed tracing works out of the box**. +There's no additional set up needed to use distributed tracing with Falcon projects. -If requests to your Falcon project include the `sentry-trace` and `baggage` headers they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. +If requests to your Falcon project include the `sentry-trace` and `baggage` headers, they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. -You need to initialize the Sentry SDK before your app has been initialized and you are good to go: +Make sure you initialize the Sentry SDK before your app: ```python import falcon diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.fastapi.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.fastapi.mdx index 8219e59406f67..b342f6800e7e9 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.fastapi.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.fastapi.mdx @@ -1,8 +1,8 @@ -If you run a FastAPI project **distributed tracing works out of the box**. +There's no additional set up needed to use distributed tracing with FastAPI projects. -If requests to your FastAPI project include the `sentry-trace` and `baggage` headers they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. +If requests to your FastAPI project include the `sentry-trace` and `baggage` headers, they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. -You need to initialize the Sentry SDK before your app has been initialized and you are good to go: +Make sure you initialize the Sentry SDK before your app: ```python from fastapi import FastAPI diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.flask.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.flask.mdx index 2e24c9758c6e1..97163d7ea2d3e 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.flask.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.flask.mdx @@ -1,8 +1,8 @@ -If you run a Flask project **distributed tracing works out of the box**. +There's no additional set up needed to use distributed tracing with Flask projects. -If requests to your Flask project include the `sentry-trace` and `baggage` headers they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. +If requests to your Flask project include the `sentry-trace` and `baggage` headers, they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. -You need to initialize the Sentry SDK before your app has been initialized and you are good to go: +Make sure you initialize the Sentry SDK before your app: ```python from flask import Flask diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.mdx index 1d27ab4c682f0..d4705ed3ed4ef 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.mdx @@ -1,3 +1,3 @@ -Distributed tracing works out of the box for the following frameworks: [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/), [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/), [Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/), [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/), [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/), [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/), [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/), [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/). +There's no additional set up needed to use distributed tracing with the following frameworks: [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/), [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/), [Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/), [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/), [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/), [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/), [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/), [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/). -If you have a vanilla Python project or us ean unsupported framework you need to implement Custom Instrumentation. +If you have a vanilla Python project or use an unsupported framework you need to add Custom Instrumentation for distributed tracing to work. diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.pyramid.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.pyramid.mdx index b9ac523cc7d8f..40ba2a71b426a 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.pyramid.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.pyramid.mdx @@ -1,8 +1,8 @@ -If you run a Pyramid project **distributed tracing works out of the box**. +There's no additional set up needed to use distributed tracing with Pyramid projects. -If requests to your Pyramid project include the `sentry-trace` and `baggage` headers they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. +If requests to your Pyramid project include the `sentry-trace` and `baggage` headers, they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. -You need to initialize the Sentry SDK before your app has been initialized and you are good to go: +Make sure you initialize the Sentry SDK before your app: ```python from pyramid.config import Configurator diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.quart.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.quart.mdx index bf6f8b16035a4..4210047af8f97 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.quart.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.quart.mdx @@ -1,8 +1,8 @@ -If you run a Quart project **distributed tracing works out of the box**. +There's no additional set up needed to use distributed tracing with Quart projects. -If requests to your Quart project include the `sentry-trace` and `baggage` headers they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. +If requests to your Quart project include the `sentry-trace` and `baggage` headers, they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. -You need to initialize the Sentry SDK before your app has been initialized and you are good to go: +Make sure you initialize the Sentry SDK before your app: ```python from quart import Quart diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.starlette.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.starlette.mdx index 212d2968283a7..453a0119acc7f 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.starlette.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.starlette.mdx @@ -1,8 +1,8 @@ -If you run a Starlette project **distributed tracing works out of the box**. +There's no additional set up needed to use distributed tracing with Starlette projects. -If requests to your Starlette project include the `sentry-trace` and `baggage` headers they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. +If requests to your Starlette project include the `sentry-trace` and `baggage` headers, they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. -You need to initialize the Sentry SDK before your app has been initialized and you are good to go: +Make sure you initialize the Sentry SDK before your app: ```python from starlette.applications import Starlette diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.tornado.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.tornado.mdx index 237fdea603f9a..36b07e42ddb6e 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.tornado.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.tornado.mdx @@ -1,8 +1,8 @@ -If you run a Tornado project **distributed tracing works out of the box**. +There's no additional set up needed to use distributed tracing with Tornado projects. -If requests to your Tornado project include the `sentry-trace` and `baggage` headers they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. +If requests to your Tornado project include the `sentry-trace` and `baggage` headers, they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. -You need to initialize the Sentry SDK before your app has been initialized and you are good to go: +Make sure you initialize the Sentry SDK before your app: ```python import tornado diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-verification/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-verification/python.mdx index 402e218254152..49abda7303699 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-verification/python.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-verification/python.mdx @@ -1,3 +1,3 @@ ## Verification -If you make outgoing HTTP requests from your project to other services, check if the HTTP headers `sentry-trace` and `baggage` are present in the request. If so distributed tracing is working. +If you make outgoing HTTP requests from your project to other services, check if the HTTP headers `sentry-trace` and `baggage` are present in the request. If so, distributed tracing is working. diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx index cd0cf2a564a02..195c28c0aceef 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx @@ -10,11 +10,9 @@ then revisit this page and change it to match the new official apis to use. -All Sentry JavaScript SDKs support distributed tracing out of the box if you add the BrowserTracing integration to your `Sentry.init` option. The [Next.js](/platforms/javascript/guides/nextjs/) and [SvelteKit](/platforms/javascript/guides/sveltekit/) SDKs already include this integration by default. +To enable distributed tracing, add the `BrowserTracing` integration to your `Sentry.init` options, as described in the Performance Automatic Instrumentation docs. The [Next.js](/platforms/javascript/guides/nextjs/) and [SvelteKit](/platforms/javascript/guides/sveltekit/) SDKs include this integration by default. -If you are using one of the integrations of Frameworks listed above, **you do not need to do anything** for distributed tracing to work! - -You can stop reading this page now and continue building an amazing product. +If you are using one of the frameworks listed above, see the Automatic Instrumentation. page on how to configure distributed tracing. @@ -23,7 +21,7 @@ Please read the note above. If you want to implement distributed tracing "by han - When loading the page, extract and store incoming tracing information from HTML `meta` tags. - When doing outgoing requests, inject tracing information to the outgoing request. -To learn more see also: How Does Distributed Tracing Work in Sentry? +To learn more, see our Distributed Tracing docs. ## Extract Tracing Information From HTML `meta` Tags @@ -95,4 +93,4 @@ The two services are now connected with your custom distributed tracing implemen ## Verification -If you make outgoing requests from your project to other services, check if the headers `sentry-trace` and `baggage` are present in the request. If so distributed tracing is working. +If you make outgoing requests from your project to other services, check if the headers `sentry-trace` and `baggage` are present in the request. If so, distributed tracing is working. diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx index d0afa46fb3e17..565ae108a8723 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx @@ -1,10 +1,8 @@ -Distributed tracing **works out of the box** for the following frameworks: Django, FastAPI, Flask, Bottle, Falcon, Pyramid, Quart, Starlette, Tornado. +There's no additional set up needed to use distributed tracing with the following frameworks: [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/), [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/), [Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/), [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/), [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/), [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/), [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/), [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/). -If you are using one of the frameworks listed above, **you do not need to do anything** for distributed tracing to work! - -You can stop reading this page now and continue building an amazing product. +If you are using one of the frameworks listed above, see the Automatic Instrumentation page for how to configure distributed tracing. @@ -15,18 +13,18 @@ Two things need to be done for distributed tracing to work: - When receiving incoming requests, extract and store incoming tracing information. - When doing outgoing requests, inject tracing information to the outgoing request. -To learn more see also: How Does Distributed Tracing Work in Sentry? +To learn more, see our Distributed Tracing docs. ## Extract Incoming Tracing Information -Incoming tracing information has to be extracted and stored in memory for later use. -This incoming tracing information can come from different places: +Incoming tracing information has to be extracted and stored in memory for later use. Sentry provides the `continue_trace` function to help with this. +Incoming tracing information can come from different places: -- In a web environment it will be sent with HTTP headers. (for example by another Sentry SDK used in your front end project) -- In a job queue (like Celery) the tracing information can be retrieved from meta or header variables. +- In a web environment it will be sent with HTTP headers, for example, by another Sentry SDK used in your frontend project. +- In a job queue, like Celery, it can be retrieved from meta or header variables. - You also can pick up tracing information from environment variables. -Whenever an incoming requests is processed by your project you need to do the following: +Here's an example of how to extract and store incoming tracing information using `continue_trace`: ```python import sentry_sdk @@ -37,7 +35,7 @@ headers = get_incoming_headers_as_dict() sentry_sdk.continue_trace(headers) ``` -In this example `get_incoming_headers_as_dict()` returns a dictorary that contains the tracing information. This dictionary would have been populated with information from HTTP headers, environment variables, or any other mechanism your project uses to communicate with the outside world. +In this example, `get_incoming_headers_as_dict()` returns a dictionary that contains tracing information. This dictionary would contain information from HTTP headers, environment variables, or any other mechanism your project uses to communicate with the outside world. Sentry's `continue_from_trace()` will extract the given headers and try to find the `sentry-trace` and `baggage` headers and it will store them in memory for later use. @@ -57,17 +55,13 @@ with start_transaction(transaction=transaction) as transaction: do_some_heavy_lifting() ``` -See the Performance Monitoring Documentation to learn what you can do with transactions. +See the Performance docs on Custom Instrumentation to learn more about using custom transactions and spans to measure the performance of your code. ## Inject Tracing Information to Outgoing Requests -On outgoing requests you have to add the two headers `sentry-trace` and `baggage` that you extracted and stored earlier. - - +For distributed tracing to work, the two headers that you extracted and stored, `sentry-trace` and `baggage`, must be added to outgoing requests. -If you are doing outgoing HTTP requests with Requests, AIOHTTP, the low level http.client (or httplib on Pyton 2) the parsed and stored tracing information is added automatically to outgoing requests. You do not need to do anything! - - +If you are sending outgoing HTTP requests with [Requests](https://requests.readthedocs.io/en/latest/), [AIOHTTP](https://docs.aiohttp.org/en/stable/), the low level [http.client](https://docs.python.org/3/library/http.client.html), or [httplib](https://docs.python.org/2/library/httplib.html) on Python 2, this tracing information is automatically added to outgoing requests. If you are do outgoing requests in another way you can generate the tracing information like follows: @@ -82,13 +76,13 @@ headers["baggage"] = sentry_sdk.get_baggage() make_an_outgoing_request(to="https://example.com", headers=headers) ``` -Now tracing information is propagated to the project running at `https://example.com`. If it has the Python SDK running, it will extract and save the tracing information for later use. +In this example, tracing information is propagated to the project running at `https://example.com`. If this project uses the Sentry Python SDK, it will extract and save the tracing information for later use. The two services are now connected with your custom distributed tracing implementation. ### Inject Tracing Information Into Rendered HTML -If you want to propagate tracing information into Javascript that is running in your rendered HTML you have to inject HTML `meta` tags into your rendered HTML: +To propagate tracing information into JavaScript running in rendered HTML you have to inject HTML `meta` tags for `sentry-trace` and `baggage` data into your rendered HTML. Here's an example: ```python import sentry_sdk @@ -117,4 +111,4 @@ render(html) ## Verification -If you make outgoing requests from your project to other services, check if the headers `sentry-trace` and `baggage` are present in the request. If so distributed tracing is working. +If you make outgoing requests from your project to other services, check if the headers `sentry-trace` and `baggage` are present in the request. If so, distributed tracing is working. diff --git a/src/platform-includes/distributed-tracing/instrumentation/index/javascript.mdx b/src/platform-includes/distributed-tracing/instrumentation/index/javascript.mdx index a31a6f7616cff..15241d4a268ac 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/index/javascript.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/index/javascript.mdx @@ -1,3 +1,3 @@ -All Sentry JavaScript SDKs support distributed tracing out of the box if you add the BrowserTracing integration to your `Sentry.init` option. The [Next.js](/platforms/javascript/guides/nextjs/) and [SvelteKit](/platforms/javascript/guides/sveltekit/) SDKs already include this integration by default. +To enable distributed tracing, add the `BrowserTracing` integration to your `Sentry.init` options, as described in the Performance Automatic Instrumentation docs. The [Next.js](/platforms/javascript/guides/nextjs/) and [SvelteKit](/platforms/javascript/guides/sveltekit/) SDKs include this integration by default. See Automatic Instrumentation to learn more. diff --git a/src/platform-includes/distributed-tracing/instrumentation/index/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/index/python.mdx index 7eec879ccab9e..a6c49ec0f0d55 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/index/python.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/index/python.mdx @@ -1,3 +1,3 @@ Distributed tracing works out of the box for the following frameworks: [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/), [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/), [Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/), [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/), [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/), [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/), [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/), [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/). -If you have a vanilla Python project or use an unsupported framework you need to implement Custom Instrumentation. +If you have a vanilla Python project or use an unsupported framework you need to add Custom Instrumentation for distributed tracing to work. diff --git a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/javascript.mdx b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/javascript.mdx index 49f0ed4c5c107..dbc8a1198866d 100644 --- a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/javascript.mdx +++ b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/javascript.mdx @@ -1,8 +1,10 @@ ## Configuration -All Sentry JavaScript SDKs support distributed tracing out of the box if you add the BrowserTracing integration to your `Sentry.init` option. The [Next.js](/platforms/javascript/guides/nextjs/) and [SvelteKit](/platforms/javascript/guides/sveltekit/) SDKs already include this integration by default. +To enable distributed tracing, add the `BrowserTracing` integration to your `Sentry.init` options, as described in the Performance Automatic Instrumentation docs. Sentry's [Next.js](/platforms/javascript/guides/nextjs/) and [SvelteKit](/platforms/javascript/guides/sveltekit/) SDKs include this integration by default. -In case your backend lives on a differnt domain, you might need to Configure Backend CORS Headers. +See the instructions at Set Up Performance for more information on how to configure tracing. + +Additionally, if your backend is hosted on a different domain, you may need to Configure Backend CORS Headers to ensure requests aren't blocked. diff --git a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/python.mdx b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/python.mdx index 3169d3b5e2cd1..850da4cb48744 100644 --- a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/python.mdx +++ b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/python.mdx @@ -1,6 +1,6 @@ ## Configuration -Distributed tracing works out of the box for the following Python frameworks: Django, FastAPI, Flask, Bottle, Falcon, Pyramid, Quart, Starlette, Tornado. +There's no additional set up needed to use distributed tracing with the following frameworks: [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/), [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/), [Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/), [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/), [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/), [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/), [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/), [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/). If you have a vanilla Python project or use an unsupported framework you need to implement Custom Instrumentation. diff --git a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/python.mdx b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/python.mdx index 006160e726590..29f161c2984ca 100644 --- a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/python.mdx +++ b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/python.mdx @@ -1,7 +1,7 @@ ## Set Up Other Services -Setup the Sentry SDK for all your other connected services. Check the Sentry documentation of the languages your connected services are written in whether distributed tracing is supported out of the box, or if you need to do some custom instrumentation. +For distributed tracing to work, you must enable it in all your connected services. To do this, follow the Distributed Tracing setup docs for each of the languages your connected services are written in. Some SDKs support distributed tracing without additional set up and some require custom instrumentation. -Check out the Javascript documentation to learn [how to setup distributed tracing in your frontend](/platforms/javascript/distributed-tracing/instrumentation/automatic-instrumentation/). +To connect a JavaScript frontend, follow the [Automatic Instrumentation](/platforms/javascript/distributed-tracing/instrumentation/automatic-instrumentation/) configuration docs. In case your Javascript connects from a differnt domain, you might need to Configure CORS Headers. diff --git a/src/platform-includes/performance/connect-services/javascript.mdx b/src/platform-includes/performance/connect-services/javascript.mdx index 0d5518f164990..2b40b0a37000d 100644 --- a/src/platform-includes/performance/connect-services/javascript.mdx +++ b/src/platform-includes/performance/connect-services/javascript.mdx @@ -8,7 +8,7 @@ The `baggage` header was added with version 7 of the Sentry Javascript SDK and i -All Sentry JavaScript SDKs support distributed tracing out of the box if you add the BrowserTracing integration to your `Sentry.init` option. The [Next.js](/platforms/javascript/guides/nextjs/) and [SvelteKit](/platforms/javascript/guides/sveltekit/) SDKs already include this integration by default. +All Sentry JavaScript SDKs support distributed tracing once you add the BrowserTracing integration to your `Sentry.init` option. The [Next.js](/platforms/javascript/guides/nextjs/) and [SvelteKit](/platforms/javascript/guides/sveltekit/) SDKs already include this integration by default. The JavaScript SDK will only attach the trace headers to outgoing HTTP requests for which the destination is a substring or regex match to the tracePropagationTargets list. `tracePropagationTargets` was previously called `tracingOrigins`. From ae5c41abfa281eb63da55c1ad76c08d200514803 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Wed, 28 Jun 2023 11:45:20 +0200 Subject: [PATCH 098/116] Apply suggestions from code review Co-authored-by: Shana Matthews --- .../custom-instrumentation/javascript.mdx | 2 -- .../custom-instrumentation/python.mdx | 16 ++++++++-------- 2 files changed, 8 insertions(+), 10 deletions(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx index 195c28c0aceef..17b16a647df2f 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx @@ -8,13 +8,11 @@ then revisit this page and change it to match the new official apis to use. --> - To enable distributed tracing, add the `BrowserTracing` integration to your `Sentry.init` options, as described in the Performance Automatic Instrumentation docs. The [Next.js](/platforms/javascript/guides/nextjs/) and [SvelteKit](/platforms/javascript/guides/sveltekit/) SDKs include this integration by default. If you are using one of the frameworks listed above, see the Automatic Instrumentation. page on how to configure distributed tracing. - Please read the note above. If you want to implement distributed tracing "by hand" two things need to be done: diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx index 565ae108a8723..49baccf1f5fa0 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx @@ -6,12 +6,10 @@ If you are using one of the frameworks listed above, see the Distributed Tracing docs. @@ -37,11 +35,13 @@ sentry_sdk.continue_trace(headers) In this example, `get_incoming_headers_as_dict()` returns a dictionary that contains tracing information. This dictionary would contain information from HTTP headers, environment variables, or any other mechanism your project uses to communicate with the outside world. -Sentry's `continue_from_trace()` will extract the given headers and try to find the `sentry-trace` and `baggage` headers and it will store them in memory for later use. +Sentry's `continue_trace()` function will extract the given headers, try to find the`sentry-trace` and `baggage` headers, and store them in memory for later use. ### Performance Monitoring in Combination With Distributed Tracing -If you want to add new transactions and spans to the trace described in the incoming headers you can do this. `continue_from_trace()` returns a transaction object that you can use to start a custom transaction: +To use distributed tracing to measure the performance of your code, you can add custom transactions and spans to incoming traces. + +Here's an example of how to use the transaction object returned from `continue_trace` to start a custom transaction: ```python import sentry_sdk @@ -63,7 +63,7 @@ For distributed tracing to work, the two headers that you extracted and stored, If you are sending outgoing HTTP requests with [Requests](https://requests.readthedocs.io/en/latest/), [AIOHTTP](https://docs.aiohttp.org/en/stable/), the low level [http.client](https://docs.python.org/3/library/http.client.html), or [httplib](https://docs.python.org/2/library/httplib.html) on Python 2, this tracing information is automatically added to outgoing requests. -If you are do outgoing requests in another way you can generate the tracing information like follows: +If you use a different library or send requests in another way you can generate this tracing information with the Sentry SDK's `get_traceparent` and `get_baggage` functions. Here's an example: ```python import sentry_sdk From 9958ef13450257aa55403150f918a9769296a192 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Wed, 28 Jun 2023 11:50:24 +0200 Subject: [PATCH 099/116] Apply suggestions from code review Co-authored-by: Shana Matthews --- .../instrumentation/custom-instrumentation/javascript.mdx | 7 +++---- .../instrumentation/custom-instrumentation/python.mdx | 2 +- .../set-up-distributed-tracing-other-services/python.mdx | 1 - 3 files changed, 4 insertions(+), 6 deletions(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx index 17b16a647df2f..207d265e72045 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx @@ -14,10 +14,10 @@ To enable distributed tracing, add the `BrowserTracing` integration to your `Sen If you are using one of the frameworks listed above, see the Automatic Instrumentation. page on how to configure distributed tracing. -Please read the note above. If you want to implement distributed tracing "by hand" two things need to be done: +If you prefer to implement custom distributed tracing, you must: -- When loading the page, extract and store incoming tracing information from HTML `meta` tags. -- When doing outgoing requests, inject tracing information to the outgoing request. +- Extract and store incoming tracing information from HTML `meta` tags when loading the page +- Inject tracing information to the outgoing request when sending outgoing requests. To learn more, see our Distributed Tracing docs. @@ -61,7 +61,6 @@ For distributed tracing to work, the two headers that you extracted and stored i Here's an example of how to collect and inject this tracing information to outgoing requests: -If you are do outgoing requests in another way you can generate the tracing information like follows: ```javascript // Create `sentry-trace` header diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx index 49baccf1f5fa0..3989c2ef7f574 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx @@ -37,7 +37,7 @@ In this example, `get_incoming_headers_as_dict()` returns a dictionary that cont Sentry's `continue_trace()` function will extract the given headers, try to find the`sentry-trace` and `baggage` headers, and store them in memory for later use. -### Performance Monitoring in Combination With Distributed Tracing +### Using Performance Monitoring With Distributed Tracing To use distributed tracing to measure the performance of your code, you can add custom transactions and spans to incoming traces. diff --git a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/python.mdx b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/python.mdx index 29f161c2984ca..997b996f9026f 100644 --- a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/python.mdx +++ b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/python.mdx @@ -4,4 +4,3 @@ For distributed tracing to work, you must enable it in all your connected servic To connect a JavaScript frontend, follow the [Automatic Instrumentation](/platforms/javascript/distributed-tracing/instrumentation/automatic-instrumentation/) configuration docs. -In case your Javascript connects from a differnt domain, you might need to Configure CORS Headers. From a97ca1afb6bf550c4ba74dd30dcef0f8004209e7 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Wed, 28 Jun 2023 12:12:22 +0200 Subject: [PATCH 100/116] Moved it up --- .../set-up-distributed-tracing-index/_default.mdx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx index d277ea7880c24..0964155a06979 100644 --- a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx +++ b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx @@ -2,14 +2,14 @@ Distributed tracing allows you to collect trace data across services. For exampl By following requests across service boundaries, distributed tracing can help you understand what happens across your entire application, in addition to seeing details for each service. +The trace gives you the complete picture of what was happing in your application as a whole, not just what was happening in one service. (You can drill down into each service from the trace.) + Here's an example showing a distributed trace in Sentry: ![A full distributed trace in Sentry](distributed-trace-in-sentry.png) This distributed trace shows a Vue app's `pageload` making a request to a Python backend, which then calls the `/api` endpoint of a Ruby microservice. -The trace gives you the complete picture of what was happing in your application as a whole, not just what was happening in one service. (You can drill down into each service from the trace.) - Sentry uses two HTTP headers to propagate tracing information between services: - `sentry-trace` From 49afd7dae65f856a94509236ae265bf1d8ccf9c6 Mon Sep 17 00:00:00 2001 From: Anton Pirker Date: Wed, 28 Jun 2023 12:14:46 +0200 Subject: [PATCH 101/116] Update src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/javascript.mdx Co-authored-by: Shana Matthews --- .../set-up-distributed-tracing-configuration/javascript.mdx | 5 ----- 1 file changed, 5 deletions(-) diff --git a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/javascript.mdx b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/javascript.mdx index dbc8a1198866d..a43139a64bbff 100644 --- a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/javascript.mdx +++ b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/javascript.mdx @@ -6,8 +6,3 @@ See the instructions at Se Additionally, if your backend is hosted on a different domain, you may need to Configure Backend CORS Headers to ensure requests aren't blocked. - - -**You need to have "Performance Monitoring" enabled!** See Set Up Performance on how to enable performance monitoring. - - From 61eb4eaf8eff5419edf0dd25b9ed3a46b1151752 Mon Sep 17 00:00:00 2001 From: "getsantry[bot]" <66042841+getsantry[bot]@users.noreply.github.com> Date: Wed, 28 Jun 2023 10:20:12 +0000 Subject: [PATCH 102/116] style(lint): Auto commit lint changes --- .../instrumentation/custom-instrumentation/javascript.mdx | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx index 207d265e72045..25de881dc2414 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx @@ -8,12 +8,10 @@ then revisit this page and change it to match the new official apis to use. --> - To enable distributed tracing, add the `BrowserTracing` integration to your `Sentry.init` options, as described in the Performance Automatic Instrumentation docs. The [Next.js](/platforms/javascript/guides/nextjs/) and [SvelteKit](/platforms/javascript/guides/sveltekit/) SDKs include this integration by default. If you are using one of the frameworks listed above, see the Automatic Instrumentation. page on how to configure distributed tracing. - If you prefer to implement custom distributed tracing, you must: - Extract and store incoming tracing information from HTML `meta` tags when loading the page @@ -61,7 +59,6 @@ For distributed tracing to work, the two headers that you extracted and stored i Here's an example of how to collect and inject this tracing information to outgoing requests: - ```javascript // Create `sentry-trace` header const sentryTraceHeader = pageLoadTransaction.toTraceparent(); From 6c5f07a2c1f3345f562e5b620a5b04c65f5409f0 Mon Sep 17 00:00:00 2001 From: "getsantry[bot]" <66042841+getsantry[bot]@users.noreply.github.com> Date: Wed, 28 Jun 2023 10:20:13 +0000 Subject: [PATCH 103/116] style(lint): Auto commit lint changes --- .../set-up-distributed-tracing-configuration/javascript.mdx | 1 - 1 file changed, 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/javascript.mdx b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/javascript.mdx index a43139a64bbff..2d5c91cbd9694 100644 --- a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/javascript.mdx +++ b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/javascript.mdx @@ -5,4 +5,3 @@ To enable distributed tracing, add the `BrowserTracing` integration to your `Sen See the instructions at Set Up Performance for more information on how to configure tracing. Additionally, if your backend is hosted on a different domain, you may need to Configure Backend CORS Headers to ensure requests aren't blocked. - From 666797ef427c4ac0f205254c28c0768b2c416edb Mon Sep 17 00:00:00 2001 From: "getsantry[bot]" <66042841+getsantry[bot]@users.noreply.github.com> Date: Wed, 28 Jun 2023 10:21:44 +0000 Subject: [PATCH 104/116] style(lint): Auto commit lint changes --- .../set-up-distributed-tracing-other-services/python.mdx | 1 - 1 file changed, 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/python.mdx b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/python.mdx index 997b996f9026f..744f21c321495 100644 --- a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/python.mdx +++ b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/python.mdx @@ -3,4 +3,3 @@ For distributed tracing to work, you must enable it in all your connected services. To do this, follow the Distributed Tracing setup docs for each of the languages your connected services are written in. Some SDKs support distributed tracing without additional set up and some require custom instrumentation. To connect a JavaScript frontend, follow the [Automatic Instrumentation](/platforms/javascript/distributed-tracing/instrumentation/automatic-instrumentation/) configuration docs. - From d394feeff5b1ef6e2a1b9b20f00bd9b7c0461011 Mon Sep 17 00:00:00 2001 From: "getsantry[bot]" <66042841+getsantry[bot]@users.noreply.github.com> Date: Wed, 28 Jun 2023 10:21:52 +0000 Subject: [PATCH 105/116] style(lint): Auto commit lint changes From 7933dd7ed39ee5b8b3ebf8358032b9ac2ef48ebc Mon Sep 17 00:00:00 2001 From: Stephanie Anderson Date: Wed, 28 Jun 2023 19:06:07 +0200 Subject: [PATCH 106/116] move distributed tracing nav item into getting started --- src/components/platformSidebar.tsx | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/src/components/platformSidebar.tsx b/src/components/platformSidebar.tsx index ced30d34ea752..1d98486a66356 100644 --- a/src/components/platformSidebar.tsx +++ b/src/components/platformSidebar.tsx @@ -71,7 +71,6 @@ export function SidebarContent({platform, guide, data}: ChildProps): JSX.Element exclude={[ `/${pathRoot}/enriching-events/`, `/${pathRoot}/data-management/`, - `/${pathRoot}/distributed-tracing/`, `/${pathRoot}/performance/`, `/${pathRoot}/session-replay/`, `/${pathRoot}/profiling/`, @@ -79,15 +78,6 @@ export function SidebarContent({platform, guide, data}: ChildProps): JSX.Element `/${pathRoot}/crons/`, ]} /> - Date: Fri, 30 Jun 2023 09:04:32 +0200 Subject: [PATCH 107/116] simplify distributed tracing docs structure --- .../custom-instrumentation/_default.mdx | 0 .../custom-instrumentation/javascript.mdx | 0 .../custom-instrumentation/python.mdx | 87 +++++++++++++ .../how-to-use/_default.mdx | 1 + .../how-to-use/python.bottle.mdx | 3 + .../how-to-use/python.django.mdx | 3 + .../how-to-use/python.falcon.mdx | 3 + .../how-to-use/python.fastapi.mdx | 3 + .../how-to-use/python.flask.mdx | 3 + .../distributed-tracing/how-to-use/python.mdx | 12 ++ .../how-to-use/python.pyramid.mdx | 3 + .../how-to-use/python.quart.mdx | 3 + .../how-to-use/python.starlette.mdx | 3 + .../how-to-use/python.tornado.mdx | 3 + .../_default.mdx | 1 - .../javascript.mdx | 8 -- .../python.mdx | 8 -- .../_default.mdx | 1 - .../automatic-instrumentation-intro/php.mdx | 6 - .../python.bottle.mdx | 18 --- .../python.django.mdx | 14 --- .../python.falcon.mdx | 18 --- .../python.fastapi.mdx | 18 --- .../python.flask.mdx | 18 --- .../python.mdx | 3 - .../python.pyramid.mdx | 19 --- .../python.quart.mdx | 21 ---- .../python.starlette.mdx | 18 --- .../python.tornado.mdx | 19 --- .../_default.mdx | 1 - .../javascript.mdx | 3 - .../python.mdx | 3 - .../custom-instrumentation/_default.mdx | 6 - .../custom-instrumentation/php.mdx | 6 - .../custom-instrumentation/python.mdx | 114 ------------------ .../instrumentation/index/_default.mdx | 6 - .../instrumentation/index/javascript.mdx | 3 - .../instrumentation/index/python.mdx | 3 - .../limiting-traces/python.mdx | 12 ++ .../_default.mdx | 1 - .../python.mdx | 22 ---- .../_default.mdx | 18 --- .../_default.mdx | 1 - .../python.mdx | 5 - .../automatic-instrumentation.mdx | 16 --- .../custom-instrumentation.mdx | 11 -- .../instrumentation/index.mdx | 12 -- .../custom-instrumentation.mdx | 9 ++ .../dealing-with-cors-issues.mdx | 11 ++ .../distributed-trace-in-sentry.png | Bin .../usage/distributed-tracing/index.mdx | 34 ++++++ .../limiting-trace-propagation.mdx | 15 +++ .../common/distributed-tracing/index.mdx | 28 ----- .../common/distributed-tracing/index.mdx | 35 ------ vercel.json | 8 ++ 55 files changed, 216 insertions(+), 484 deletions(-) create mode 100644 src/platform-includes/distributed-tracing/custom-instrumentation/_default.mdx rename src/platform-includes/distributed-tracing/{instrumentation => }/custom-instrumentation/javascript.mdx (100%) create mode 100644 src/platform-includes/distributed-tracing/custom-instrumentation/python.mdx create mode 100644 src/platform-includes/distributed-tracing/how-to-use/_default.mdx create mode 100644 src/platform-includes/distributed-tracing/how-to-use/python.bottle.mdx create mode 100644 src/platform-includes/distributed-tracing/how-to-use/python.django.mdx create mode 100644 src/platform-includes/distributed-tracing/how-to-use/python.falcon.mdx create mode 100644 src/platform-includes/distributed-tracing/how-to-use/python.fastapi.mdx create mode 100644 src/platform-includes/distributed-tracing/how-to-use/python.flask.mdx create mode 100644 src/platform-includes/distributed-tracing/how-to-use/python.mdx create mode 100644 src/platform-includes/distributed-tracing/how-to-use/python.pyramid.mdx create mode 100644 src/platform-includes/distributed-tracing/how-to-use/python.quart.mdx create mode 100644 src/platform-includes/distributed-tracing/how-to-use/python.starlette.mdx create mode 100644 src/platform-includes/distributed-tracing/how-to-use/python.tornado.mdx delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/_default.mdx delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/php.mdx delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.bottle.mdx delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.django.mdx delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.falcon.mdx delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.fastapi.mdx delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.flask.mdx delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.mdx delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.pyramid.mdx delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.quart.mdx delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.starlette.mdx delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.tornado.mdx delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-verification/_default.mdx delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-verification/javascript.mdx delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-verification/python.mdx delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/_default.mdx delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/php.mdx delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/index/_default.mdx delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/index/javascript.mdx delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/index/python.mdx create mode 100644 src/platform-includes/distributed-tracing/limiting-traces/python.mdx delete mode 100644 src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/_default.mdx delete mode 100644 src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/python.mdx delete mode 100644 src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx delete mode 100644 src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/_default.mdx delete mode 100644 src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/python.mdx delete mode 100644 src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx delete mode 100644 src/platforms/common/distributed-tracing/instrumentation/custom-instrumentation.mdx delete mode 100644 src/platforms/common/distributed-tracing/instrumentation/index.mdx create mode 100644 src/platforms/common/usage/distributed-tracing/custom-instrumentation.mdx create mode 100644 src/platforms/common/usage/distributed-tracing/dealing-with-cors-issues.mdx rename src/{platform-includes/distributed-tracing/set-up-distributed-tracing-index => platforms/common/usage/distributed-tracing}/distributed-trace-in-sentry.png (100%) create mode 100644 src/platforms/common/usage/distributed-tracing/index.mdx create mode 100644 src/platforms/common/usage/distributed-tracing/limiting-trace-propagation.mdx delete mode 100644 src/platforms/javascript/common/distributed-tracing/index.mdx delete mode 100644 src/platforms/python/common/distributed-tracing/index.mdx diff --git a/src/platform-includes/distributed-tracing/custom-instrumentation/_default.mdx b/src/platform-includes/distributed-tracing/custom-instrumentation/_default.mdx new file mode 100644 index 0000000000000..e69de29bb2d1d diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx b/src/platform-includes/distributed-tracing/custom-instrumentation/javascript.mdx similarity index 100% rename from src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/javascript.mdx rename to src/platform-includes/distributed-tracing/custom-instrumentation/javascript.mdx diff --git a/src/platform-includes/distributed-tracing/custom-instrumentation/python.mdx b/src/platform-includes/distributed-tracing/custom-instrumentation/python.mdx new file mode 100644 index 0000000000000..64ddbdd91262f --- /dev/null +++ b/src/platform-includes/distributed-tracing/custom-instrumentation/python.mdx @@ -0,0 +1,87 @@ +On this page you will learn how to manually propagate trace information into and out of your Python application. Please note, that you do not need to do this manually, if you use one of our supported frameworks, or you have our performance monitoring feature turned on. + +To set it up manually, all you have to do is to make sure your application extracts incoming headers and to set those headers again when making an outgoing request within your application. + +## Extract Incoming Tracing Information + +Incoming tracing information has to be extracted and stored in memory for later use. Sentry provides the `continue_trace()` function to help you with this. Incoming tracing information can come from different places: + +- In a web environment it will be sent with HTTP headers, for example, by another Sentry SDK used in your frontend project. +- In a job queue, like Celery, it can be retrieved from meta or header variables. +- You also can pick up tracing information from environment variables. + +Here's an example of how to extract and store incoming tracing information using `continue_trace()`: + +```python +import sentry_sdk +from my_project import get_incoming_headers_as_dict + +headers = get_incoming_headers_as_dict() + +sentry_sdk.continue_trace(headers) +``` + +In this example, `get_incoming_headers_as_dict()` returns a dictionary that contains tracing information from HTTP headers, environment variables, or any other mechanism your project uses to communicate with the outside world. + +Sentry's `continue_trace()` function will extract the given headers, try to find the `sentry-trace` and `baggage` headers, and store them in memory for later use. + + +## Inject Tracing Information to Outgoing Requests + +For distributed tracing to work, the two headers `sentry-trace` and `baggage`, must now also be added to outgoing requests. + +If you are sending outgoing HTTP requests with [Requests](https://requests.readthedocs.io/en/latest/), [AIOHTTP](https://docs.aiohttp.org/en/stable/), the low level [http.client](https://docs.python.org/3/library/http.client.html), or [httplib](https://docs.python.org/2/library/httplib.html) on Python 2, this tracing information is automatically added to outgoing requests. + +If your using none of the above, you can generate this tracing information with the Sentry SDK's `get_traceparent()` and `get_baggage()` functions. Here's an example: + +```python +import sentry_sdk +from my_project import make_an_outgoing_request + +headers = {} +headers["sentry-trace"] = sentry_sdk.get_traceparent() +headers["baggage"] = sentry_sdk.get_baggage() + +make_an_outgoing_request(to="https://example.com", headers=headers) +``` + +In this example, tracing information is propagated to the project running at `https://example.com`. If this project uses the Sentry Python SDK, it will extract and save the tracing information for later use. + +The two services are now connected with your custom distributed tracing implementation. + + + + + +### Inject Tracing Information Into Rendered HTML + +To propagate tracing information into JavaScript running in rendered HTML you have to inject HTML `meta` tags for `sentry-trace` and `baggage` data into your rendered HTML. Here's an example: + +```python +import sentry_sdk +from my_project import render + +meta = "" +meta += '' % sentry_sdk.get_traceparent() +meta += '' % sentry_sdk.get_baggage() + +html = """ + + + + + {additional_meta} + + +

This is a website.

+ + +""".format(additional_meta=meta) + +render(html) + +``` + +## Verification + +If you make outgoing requests from your project to other services, check if the headers `sentry-trace` and `baggage` are present in the request. If so, distributed tracing is working. diff --git a/src/platform-includes/distributed-tracing/how-to-use/_default.mdx b/src/platform-includes/distributed-tracing/how-to-use/_default.mdx new file mode 100644 index 0000000000000..90cfad426f4ab --- /dev/null +++ b/src/platform-includes/distributed-tracing/how-to-use/_default.mdx @@ -0,0 +1 @@ +In order to use distributed tracing with this SDK, you have to activate performance monitoring. diff --git a/src/platform-includes/distributed-tracing/how-to-use/python.bottle.mdx b/src/platform-includes/distributed-tracing/how-to-use/python.bottle.mdx new file mode 100644 index 0000000000000..a34bc0fe4db7d --- /dev/null +++ b/src/platform-includes/distributed-tracing/how-to-use/python.bottle.mdx @@ -0,0 +1,3 @@ +If you use the current version of our Python SDK, distributed tracing just works out of the box. No additional configuration is required. + +If you however use version `1.25.x` or below, you need to have our "Performance Monitoring" feature enabled for distributed tracing to work. Learn more in Set Up Performance. diff --git a/src/platform-includes/distributed-tracing/how-to-use/python.django.mdx b/src/platform-includes/distributed-tracing/how-to-use/python.django.mdx new file mode 100644 index 0000000000000..a34bc0fe4db7d --- /dev/null +++ b/src/platform-includes/distributed-tracing/how-to-use/python.django.mdx @@ -0,0 +1,3 @@ +If you use the current version of our Python SDK, distributed tracing just works out of the box. No additional configuration is required. + +If you however use version `1.25.x` or below, you need to have our "Performance Monitoring" feature enabled for distributed tracing to work. Learn more in Set Up Performance. diff --git a/src/platform-includes/distributed-tracing/how-to-use/python.falcon.mdx b/src/platform-includes/distributed-tracing/how-to-use/python.falcon.mdx new file mode 100644 index 0000000000000..a34bc0fe4db7d --- /dev/null +++ b/src/platform-includes/distributed-tracing/how-to-use/python.falcon.mdx @@ -0,0 +1,3 @@ +If you use the current version of our Python SDK, distributed tracing just works out of the box. No additional configuration is required. + +If you however use version `1.25.x` or below, you need to have our "Performance Monitoring" feature enabled for distributed tracing to work. Learn more in Set Up Performance. diff --git a/src/platform-includes/distributed-tracing/how-to-use/python.fastapi.mdx b/src/platform-includes/distributed-tracing/how-to-use/python.fastapi.mdx new file mode 100644 index 0000000000000..a34bc0fe4db7d --- /dev/null +++ b/src/platform-includes/distributed-tracing/how-to-use/python.fastapi.mdx @@ -0,0 +1,3 @@ +If you use the current version of our Python SDK, distributed tracing just works out of the box. No additional configuration is required. + +If you however use version `1.25.x` or below, you need to have our "Performance Monitoring" feature enabled for distributed tracing to work. Learn more in Set Up Performance. diff --git a/src/platform-includes/distributed-tracing/how-to-use/python.flask.mdx b/src/platform-includes/distributed-tracing/how-to-use/python.flask.mdx new file mode 100644 index 0000000000000..a34bc0fe4db7d --- /dev/null +++ b/src/platform-includes/distributed-tracing/how-to-use/python.flask.mdx @@ -0,0 +1,3 @@ +If you use the current version of our Python SDK, distributed tracing just works out of the box. No additional configuration is required. + +If you however use version `1.25.x` or below, you need to have our "Performance Monitoring" feature enabled for distributed tracing to work. Learn more in Set Up Performance. diff --git a/src/platform-includes/distributed-tracing/how-to-use/python.mdx b/src/platform-includes/distributed-tracing/how-to-use/python.mdx new file mode 100644 index 0000000000000..1fe1f1214a423 --- /dev/null +++ b/src/platform-includes/distributed-tracing/how-to-use/python.mdx @@ -0,0 +1,12 @@ +If you use the current version of our Python SDK, distributed tracing just works out of the box for the following frameworks: +- [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/) +- [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/) +- [Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/) +- [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/) +- [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/) +- [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/) +- [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/) +- [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/) +- [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/) + +If you however use version `1.25.x` or below, you need to have our performance monitoring feature enabled for distributed tracing to work. However, if you do not want to activate performance monitoring, you can also setup a custom instrumentation. diff --git a/src/platform-includes/distributed-tracing/how-to-use/python.pyramid.mdx b/src/platform-includes/distributed-tracing/how-to-use/python.pyramid.mdx new file mode 100644 index 0000000000000..a34bc0fe4db7d --- /dev/null +++ b/src/platform-includes/distributed-tracing/how-to-use/python.pyramid.mdx @@ -0,0 +1,3 @@ +If you use the current version of our Python SDK, distributed tracing just works out of the box. No additional configuration is required. + +If you however use version `1.25.x` or below, you need to have our "Performance Monitoring" feature enabled for distributed tracing to work. Learn more in Set Up Performance. diff --git a/src/platform-includes/distributed-tracing/how-to-use/python.quart.mdx b/src/platform-includes/distributed-tracing/how-to-use/python.quart.mdx new file mode 100644 index 0000000000000..a34bc0fe4db7d --- /dev/null +++ b/src/platform-includes/distributed-tracing/how-to-use/python.quart.mdx @@ -0,0 +1,3 @@ +If you use the current version of our Python SDK, distributed tracing just works out of the box. No additional configuration is required. + +If you however use version `1.25.x` or below, you need to have our "Performance Monitoring" feature enabled for distributed tracing to work. Learn more in Set Up Performance. diff --git a/src/platform-includes/distributed-tracing/how-to-use/python.starlette.mdx b/src/platform-includes/distributed-tracing/how-to-use/python.starlette.mdx new file mode 100644 index 0000000000000..a34bc0fe4db7d --- /dev/null +++ b/src/platform-includes/distributed-tracing/how-to-use/python.starlette.mdx @@ -0,0 +1,3 @@ +If you use the current version of our Python SDK, distributed tracing just works out of the box. No additional configuration is required. + +If you however use version `1.25.x` or below, you need to have our "Performance Monitoring" feature enabled for distributed tracing to work. Learn more in Set Up Performance. diff --git a/src/platform-includes/distributed-tracing/how-to-use/python.tornado.mdx b/src/platform-includes/distributed-tracing/how-to-use/python.tornado.mdx new file mode 100644 index 0000000000000..a34bc0fe4db7d --- /dev/null +++ b/src/platform-includes/distributed-tracing/how-to-use/python.tornado.mdx @@ -0,0 +1,3 @@ +If you use the current version of our Python SDK, distributed tracing just works out of the box. No additional configuration is required. + +If you however use version `1.25.x` or below, you need to have our "Performance Monitoring" feature enabled for distributed tracing to work. Learn more in Set Up Performance. diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/_default.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/_default.mdx deleted file mode 100644 index 556ac4a3344a2..0000000000000 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/_default.mdx +++ /dev/null @@ -1 +0,0 @@ -# AUTOMATIC INSTRUMENTATION CONFIGURATION DEFAULT diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx index dbeb0c963fa43..ceef6c2cd435e 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx @@ -18,11 +18,3 @@ Sentry.init({ In this example, trace information will be added to outgoing XHR/fetch requests to `localhost` and URLs starting with `https://api.example.com`. See Tracing Options docs for more information about the `trace_propagation_targets` option. - -### Configure Backend CORS Headers - -If your backend is hosted on a different domain than your frontend, for example, your frontend on is `https://example.com` and your backend is on `https://api.example.com`, and the frontend does XHR/fetch requests to your backend, you'll need to configure your backend [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers) headers to ensure requests aren't blocked. - -Configure your backend CORS to allow the `sentry-trace` and `baggage` headers. - -Your server's response header configuration might look like: `"Access-Control-Allow-Headers: sentry-trace, baggage"`. Your configuration will be specific to your setup. diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx index d3d184c7f2b1d..98a5559bf7260 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx @@ -18,11 +18,3 @@ sentry_sdk.init( In the example above, trace information will be added to all requests to URLs that contain `"https://myproject.org"` and to all URLs of all sub domains of `otherservice.org` like `https://api.otherservice.org/something/` or `https://payment.otherservice.org/something/`. See Tracing Options docs for more information about the `trace_propagation_targets` option. - -### Configure CORS Headers - -If your backend is hosted on a different domain than your frontend, for example, your frontend on is `https://example.com` and your backend is on `https://api.example.com`, and the frontend does XHR/fetch requests to your backend, you'll need to configure your backend [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers) headers to ensure requests aren't blocked. - -Configure your backend CORS to allow the `sentry-trace` and `baggage` headers. - -Your server's response header configuration might look like: `"Access-Control-Allow-Headers: sentry-trace, baggage"`. Your configuration will be specific to your setup. diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/_default.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/_default.mdx index f4cc63b9c23b2..e69de29bb2d1d 100644 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/_default.mdx +++ b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/_default.mdx @@ -1 +0,0 @@ -# AUTOMATIC INSTRUMENTATION CONFIGURATION INTRO diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/php.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/php.mdx deleted file mode 100644 index 380fd2c2bec28..0000000000000 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/php.mdx +++ /dev/null @@ -1,6 +0,0 @@ -# AUTOMATIC PHP - - - Please refer to tracing with and without performance activated and delete this - note and its headline afterwards. - diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.bottle.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.bottle.mdx deleted file mode 100644 index 375ab31e4593b..0000000000000 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.bottle.mdx +++ /dev/null @@ -1,18 +0,0 @@ -There's no additional set up needed to use distributed tracing with Bottle projects. - -If requests to your Bottle project include the `sentry-trace` and `baggage` headers, they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Bottle project. - -Make sure you initialize the Sentry SDK before your app: - -```python -from bottle import Bottle -import sentry_sdk - - -sentry_sdk.init( - dsn="___PUBLIC_DSN___", - # ... -) - -app = Bottle() -``` diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.django.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.django.mdx deleted file mode 100644 index 1072d30600305..0000000000000 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.django.mdx +++ /dev/null @@ -1,14 +0,0 @@ -There's no additional set up needed to use distributed tracing with Django projects. - -If requests to your Django project include the `sentry-trace` and `baggage` headers, they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. - -Make sure you initialize the Sentry SDK in your `settings.py` file: - -```python -import sentry_sdk - -sentry_sdk.init( - dsn="___PUBLIC_DSN___", - # ... -) -``` diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.falcon.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.falcon.mdx deleted file mode 100644 index eec6f68ee301f..0000000000000 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.falcon.mdx +++ /dev/null @@ -1,18 +0,0 @@ -There's no additional set up needed to use distributed tracing with Falcon projects. - -If requests to your Falcon project include the `sentry-trace` and `baggage` headers, they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. - -Make sure you initialize the Sentry SDK before your app: - -```python -import falcon -import sentry_sdk - - -sentry_sdk.init( - dsn="___PUBLIC_DSN___", - # ... -) - -api = falcon.API() -``` diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.fastapi.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.fastapi.mdx deleted file mode 100644 index b342f6800e7e9..0000000000000 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.fastapi.mdx +++ /dev/null @@ -1,18 +0,0 @@ -There's no additional set up needed to use distributed tracing with FastAPI projects. - -If requests to your FastAPI project include the `sentry-trace` and `baggage` headers, they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. - -Make sure you initialize the Sentry SDK before your app: - -```python -from fastapi import FastAPI -import sentry_sdk - - -sentry_sdk.init( - dsn="___PUBLIC_DSN___", - # ... -) - -api = FastAPI() -``` diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.flask.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.flask.mdx deleted file mode 100644 index 97163d7ea2d3e..0000000000000 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.flask.mdx +++ /dev/null @@ -1,18 +0,0 @@ -There's no additional set up needed to use distributed tracing with Flask projects. - -If requests to your Flask project include the `sentry-trace` and `baggage` headers, they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. - -Make sure you initialize the Sentry SDK before your app: - -```python -from flask import Flask -import sentry_sdk - - -sentry_sdk.init( - dsn="___PUBLIC_DSN___", - # ... -) - -api = Flask(__name__) -``` diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.mdx deleted file mode 100644 index d4705ed3ed4ef..0000000000000 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.mdx +++ /dev/null @@ -1,3 +0,0 @@ -There's no additional set up needed to use distributed tracing with the following frameworks: [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/), [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/), [Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/), [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/), [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/), [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/), [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/), [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/). - -If you have a vanilla Python project or use an unsupported framework you need to add Custom Instrumentation for distributed tracing to work. diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.pyramid.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.pyramid.mdx deleted file mode 100644 index 40ba2a71b426a..0000000000000 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.pyramid.mdx +++ /dev/null @@ -1,19 +0,0 @@ -There's no additional set up needed to use distributed tracing with Pyramid projects. - -If requests to your Pyramid project include the `sentry-trace` and `baggage` headers, they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. - -Make sure you initialize the Sentry SDK before your app: - -```python -from pyramid.config import Configurator -import sentry_sdk - - -sentry_sdk.init( - dsn="___PUBLIC_DSN___", - # ... -) - -with Configurator() as config: - # ... -``` diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.quart.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.quart.mdx deleted file mode 100644 index 4210047af8f97..0000000000000 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.quart.mdx +++ /dev/null @@ -1,21 +0,0 @@ -There's no additional set up needed to use distributed tracing with Quart projects. - -If requests to your Quart project include the `sentry-trace` and `baggage` headers, they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. - -Make sure you initialize the Sentry SDK before your app: - -```python -from quart import Quart -import sentry_sdk - - -sentry_sdk.init( - dsn="___PUBLIC_DSN___", - integrations=[ - QuartIntegration(), - ], - # ... -) - -app = Quart(__name__) -``` diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.starlette.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.starlette.mdx deleted file mode 100644 index 453a0119acc7f..0000000000000 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.starlette.mdx +++ /dev/null @@ -1,18 +0,0 @@ -There's no additional set up needed to use distributed tracing with Starlette projects. - -If requests to your Starlette project include the `sentry-trace` and `baggage` headers, they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. - -Make sure you initialize the Sentry SDK before your app: - -```python -from starlette.applications import Starlette -import sentry_sdk - - -sentry_sdk.init( - dsn="___PUBLIC_DSN___", - # ... -) - -app = Starlette(routes=[...]) -``` diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.tornado.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.tornado.mdx deleted file mode 100644 index 36b07e42ddb6e..0000000000000 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/python.tornado.mdx +++ /dev/null @@ -1,19 +0,0 @@ -There's no additional set up needed to use distributed tracing with Tornado projects. - -If requests to your Tornado project include the `sentry-trace` and `baggage` headers, they will be parsed automatically and the headers will also be added to all outgoing HTTP requests from your Django project. - -Make sure you initialize the Sentry SDK before your app: - -```python -import tornado -import sentry_sdk - - -sentry_sdk.init( - dsn="___PUBLIC_DSN___", - # ... -) - -class MainHandler(tornado.web.RequestHandler): - # ... -``` diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-verification/_default.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-verification/_default.mdx deleted file mode 100644 index e439cbebe1c43..0000000000000 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-verification/_default.mdx +++ /dev/null @@ -1 +0,0 @@ -# AUTOMATIC INSTRUMENTATION CONFIGURATION VERIFICATION diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-verification/javascript.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-verification/javascript.mdx deleted file mode 100644 index b45b75e81ba62..0000000000000 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-verification/javascript.mdx +++ /dev/null @@ -1,3 +0,0 @@ -## Verification - -If you make outgoing XHR/fetch requests from your project to other services, check if the HTTP headers `sentry-trace` and `baggage` are present in the request. If so, distributed tracing is working. diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-verification/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-verification/python.mdx deleted file mode 100644 index 49abda7303699..0000000000000 --- a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-verification/python.mdx +++ /dev/null @@ -1,3 +0,0 @@ -## Verification - -If you make outgoing HTTP requests from your project to other services, check if the HTTP headers `sentry-trace` and `baggage` are present in the request. If so, distributed tracing is working. diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/_default.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/_default.mdx deleted file mode 100644 index 490b440acff93..0000000000000 --- a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/_default.mdx +++ /dev/null @@ -1,6 +0,0 @@ -# CUSTOM DEFAULT - - - Please refer to tracing with and without performance activated and delete this - note and its headline afterwards. - diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/php.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/php.mdx deleted file mode 100644 index f87634b547c32..0000000000000 --- a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/php.mdx +++ /dev/null @@ -1,6 +0,0 @@ -# CUSTOM PHP - - - Please refer to tracing with and without performance activated and delete this - note and its headline afterwards. - diff --git a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx deleted file mode 100644 index 3989c2ef7f574..0000000000000 --- a/src/platform-includes/distributed-tracing/instrumentation/custom-instrumentation/python.mdx +++ /dev/null @@ -1,114 +0,0 @@ - - -There's no additional set up needed to use distributed tracing with the following frameworks: [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/), [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/), [Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/), [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/), [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/), [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/), [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/), [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/). - -If you are using one of the frameworks listed above, see the Automatic Instrumentation page for how to configure distributed tracing. - - - -To add distributed tracing to a vanilla Python project or a project with an unsupported framework, you must: - -- Extract and store incoming tracing information when receiving incoming requests. -- Inject tracing information to the outgoing request when sending outgoing requests. - -To learn more, see our Distributed Tracing docs. - -## Extract Incoming Tracing Information - -Incoming tracing information has to be extracted and stored in memory for later use. Sentry provides the `continue_trace` function to help with this. -Incoming tracing information can come from different places: - -- In a web environment it will be sent with HTTP headers, for example, by another Sentry SDK used in your frontend project. -- In a job queue, like Celery, it can be retrieved from meta or header variables. -- You also can pick up tracing information from environment variables. - -Here's an example of how to extract and store incoming tracing information using `continue_trace`: - -```python -import sentry_sdk -from my_project import get_incoming_headers_as_dict - -headers = get_incoming_headers_as_dict() - -sentry_sdk.continue_trace(headers) -``` - -In this example, `get_incoming_headers_as_dict()` returns a dictionary that contains tracing information. This dictionary would contain information from HTTP headers, environment variables, or any other mechanism your project uses to communicate with the outside world. - -Sentry's `continue_trace()` function will extract the given headers, try to find the`sentry-trace` and `baggage` headers, and store them in memory for later use. - -### Using Performance Monitoring With Distributed Tracing - -To use distributed tracing to measure the performance of your code, you can add custom transactions and spans to incoming traces. - -Here's an example of how to use the transaction object returned from `continue_trace` to start a custom transaction: - -```python -import sentry_sdk -from my_project import get_incoming_headers_as_dict, do_some_heavy_lifting - -headers = get_incoming_headers_as_dict() - -transaction = sentry_sdk.continue_trace(headers) - -with start_transaction(transaction=transaction) as transaction: - do_some_heavy_lifting() -``` - -See the Performance docs on Custom Instrumentation to learn more about using custom transactions and spans to measure the performance of your code. - -## Inject Tracing Information to Outgoing Requests - -For distributed tracing to work, the two headers that you extracted and stored, `sentry-trace` and `baggage`, must be added to outgoing requests. - -If you are sending outgoing HTTP requests with [Requests](https://requests.readthedocs.io/en/latest/), [AIOHTTP](https://docs.aiohttp.org/en/stable/), the low level [http.client](https://docs.python.org/3/library/http.client.html), or [httplib](https://docs.python.org/2/library/httplib.html) on Python 2, this tracing information is automatically added to outgoing requests. - -If you use a different library or send requests in another way you can generate this tracing information with the Sentry SDK's `get_traceparent` and `get_baggage` functions. Here's an example: - -```python -import sentry_sdk -from my_project import make_an_outgoing_request - -headers = {} -headers["sentry-trace"] = sentry_sdk.get_traceparent() -headers["baggage"] = sentry_sdk.get_baggage() - -make_an_outgoing_request(to="https://example.com", headers=headers) -``` - -In this example, tracing information is propagated to the project running at `https://example.com`. If this project uses the Sentry Python SDK, it will extract and save the tracing information for later use. - -The two services are now connected with your custom distributed tracing implementation. - -### Inject Tracing Information Into Rendered HTML - -To propagate tracing information into JavaScript running in rendered HTML you have to inject HTML `meta` tags for `sentry-trace` and `baggage` data into your rendered HTML. Here's an example: - -```python -import sentry_sdk -from my_project import render - -meta = "" -meta += '' % sentry_sdk.get_traceparent() -meta += '' % sentry_sdk.get_baggage() - -html = """ - - - - - {additional_meta} - - -

This is a website.

- - -""".format(additional_meta=meta) - -render(html) - -``` - -## Verification - -If you make outgoing requests from your project to other services, check if the headers `sentry-trace` and `baggage` are present in the request. If so, distributed tracing is working. diff --git a/src/platform-includes/distributed-tracing/instrumentation/index/_default.mdx b/src/platform-includes/distributed-tracing/instrumentation/index/_default.mdx deleted file mode 100644 index ea0b160485187..0000000000000 --- a/src/platform-includes/distributed-tracing/instrumentation/index/_default.mdx +++ /dev/null @@ -1,6 +0,0 @@ -# INDEX DEFAULT - - - Please refer to tracing with and without performance activated and delete this - note and its headline afterwards. - diff --git a/src/platform-includes/distributed-tracing/instrumentation/index/javascript.mdx b/src/platform-includes/distributed-tracing/instrumentation/index/javascript.mdx deleted file mode 100644 index 15241d4a268ac..0000000000000 --- a/src/platform-includes/distributed-tracing/instrumentation/index/javascript.mdx +++ /dev/null @@ -1,3 +0,0 @@ -To enable distributed tracing, add the `BrowserTracing` integration to your `Sentry.init` options, as described in the Performance Automatic Instrumentation docs. The [Next.js](/platforms/javascript/guides/nextjs/) and [SvelteKit](/platforms/javascript/guides/sveltekit/) SDKs include this integration by default. - -See Automatic Instrumentation to learn more. diff --git a/src/platform-includes/distributed-tracing/instrumentation/index/python.mdx b/src/platform-includes/distributed-tracing/instrumentation/index/python.mdx deleted file mode 100644 index a6c49ec0f0d55..0000000000000 --- a/src/platform-includes/distributed-tracing/instrumentation/index/python.mdx +++ /dev/null @@ -1,3 +0,0 @@ -Distributed tracing works out of the box for the following frameworks: [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/), [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/), [Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/), [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/), [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/), [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/), [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/), [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/). - -If you have a vanilla Python project or use an unsupported framework you need to add Custom Instrumentation for distributed tracing to work. diff --git a/src/platform-includes/distributed-tracing/limiting-traces/python.mdx b/src/platform-includes/distributed-tracing/limiting-traces/python.mdx new file mode 100644 index 0000000000000..02b20df5b4139 --- /dev/null +++ b/src/platform-includes/distributed-tracing/limiting-traces/python.mdx @@ -0,0 +1,12 @@ +```python +import sentry_sdk + +sentry_sdk.init( + dsn="___PUBLIC_DSN___", + trace_propagation_targets=[ + "https://myproject.org", + r"https://.*\.otherservice.org/.*", + ], + # ... +) +``` diff --git a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/_default.mdx b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/_default.mdx deleted file mode 100644 index 72a07ade5e371..0000000000000 --- a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/_default.mdx +++ /dev/null @@ -1 +0,0 @@ - diff --git a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/python.mdx b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/python.mdx deleted file mode 100644 index 850da4cb48744..0000000000000 --- a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/python.mdx +++ /dev/null @@ -1,22 +0,0 @@ -## Configuration - -There's no additional set up needed to use distributed tracing with the following frameworks: [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/), [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/), [Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/), [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/), [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/), [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/), [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/), [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/), [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/). - -If you have a vanilla Python project or use an unsupported framework you need to implement Custom Instrumentation. - - - -In Python SDKs version `1.25.x` and below you need to have "Performance Monitoring" enabled for distributed tracing to work. Learn more in Set Up Performance. - - - - diff --git a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx deleted file mode 100644 index 0964155a06979..0000000000000 --- a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/_default.mdx +++ /dev/null @@ -1,18 +0,0 @@ -Distributed tracing allows you to collect trace data across services. For example, with distributed tracing you can collect traces that contain data from requests that have passed through your web frontend, mobile app, backend, and microservices. - -By following requests across service boundaries, distributed tracing can help you understand what happens across your entire application, in addition to seeing details for each service. - -The trace gives you the complete picture of what was happing in your application as a whole, not just what was happening in one service. (You can drill down into each service from the trace.) - -Here's an example showing a distributed trace in Sentry: - -![A full distributed trace in Sentry](distributed-trace-in-sentry.png) - -This distributed trace shows a Vue app's `pageload` making a request to a Python backend, which then calls the `/api` endpoint of a Ruby microservice. - -Sentry uses two HTTP headers to propagate tracing information between services: - -- `sentry-trace` -- `baggage` - -To ensure distributed tracing works correctly, you must add these headers to your CORS allowlist and ensure they aren't blocked or stripped by your proxy servers, gateways, or firewalls. diff --git a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/_default.mdx b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/_default.mdx deleted file mode 100644 index 30b19be3bdcb8..0000000000000 --- a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/_default.mdx +++ /dev/null @@ -1 +0,0 @@ - diff --git a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/python.mdx b/src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/python.mdx deleted file mode 100644 index 744f21c321495..0000000000000 --- a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-other-services/python.mdx +++ /dev/null @@ -1,5 +0,0 @@ -## Set Up Other Services - -For distributed tracing to work, you must enable it in all your connected services. To do this, follow the Distributed Tracing setup docs for each of the languages your connected services are written in. Some SDKs support distributed tracing without additional set up and some require custom instrumentation. - -To connect a JavaScript frontend, follow the [Automatic Instrumentation](/platforms/javascript/distributed-tracing/instrumentation/automatic-instrumentation/) configuration docs. diff --git a/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx b/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx deleted file mode 100644 index 1943539925eef..0000000000000 --- a/src/platforms/common/distributed-tracing/instrumentation/automatic-instrumentation.mdx +++ /dev/null @@ -1,16 +0,0 @@ ---- -title: Automatic Instrumentation -sidebar_order: 40 -description: "" -supported: - - javascript - - python -notSupported: - - javascript.cordova ---- - - - - - - diff --git a/src/platforms/common/distributed-tracing/instrumentation/custom-instrumentation.mdx b/src/platforms/common/distributed-tracing/instrumentation/custom-instrumentation.mdx deleted file mode 100644 index b888dacba3e5b..0000000000000 --- a/src/platforms/common/distributed-tracing/instrumentation/custom-instrumentation.mdx +++ /dev/null @@ -1,11 +0,0 @@ ---- -title: Custom Instrumentation -sidebar_order: 40 -description: "" -supported: - - python -notSupported: - - javascript.cordova ---- - - diff --git a/src/platforms/common/distributed-tracing/instrumentation/index.mdx b/src/platforms/common/distributed-tracing/instrumentation/index.mdx deleted file mode 100644 index 05e12cd9557d4..0000000000000 --- a/src/platforms/common/distributed-tracing/instrumentation/index.mdx +++ /dev/null @@ -1,12 +0,0 @@ ---- -title: Instrumentation -sidebar_order: 40 -description: "" -supported: - - javascript - - python -notSupported: - - javascript.cordova ---- - - diff --git a/src/platforms/common/usage/distributed-tracing/custom-instrumentation.mdx b/src/platforms/common/usage/distributed-tracing/custom-instrumentation.mdx new file mode 100644 index 0000000000000..9c436537f8bec --- /dev/null +++ b/src/platforms/common/usage/distributed-tracing/custom-instrumentation.mdx @@ -0,0 +1,9 @@ +--- +title: Custom Instrumentation +sidebar_order: 40 +description: "" +supported: + - python +--- + + diff --git a/src/platforms/common/usage/distributed-tracing/dealing-with-cors-issues.mdx b/src/platforms/common/usage/distributed-tracing/dealing-with-cors-issues.mdx new file mode 100644 index 0000000000000..42748ffe2b150 --- /dev/null +++ b/src/platforms/common/usage/distributed-tracing/dealing-with-cors-issues.mdx @@ -0,0 +1,11 @@ +--- +title: Dealing with CORS Issues +sidebar_order: 80 +description: "" +--- + +If your backend is hosted on a different domain than your frontend, for example, your frontend on is `https://example.com` and your backend is on `https://api.example.com`, and the frontend does XHR/fetch requests to your backend, you'll need to configure your backend [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers) headers to ensure requests aren't blocked. + +Configure your backend CORS to allow the `sentry-trace` and `baggage` headers. + +Your server's response header configuration might look like: `"Access-Control-Allow-Headers: sentry-trace, baggage"`. Your configuration will be specific to your setup. diff --git a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/distributed-trace-in-sentry.png b/src/platforms/common/usage/distributed-tracing/distributed-trace-in-sentry.png similarity index 100% rename from src/platform-includes/distributed-tracing/set-up-distributed-tracing-index/distributed-trace-in-sentry.png rename to src/platforms/common/usage/distributed-tracing/distributed-trace-in-sentry.png diff --git a/src/platforms/common/usage/distributed-tracing/index.mdx b/src/platforms/common/usage/distributed-tracing/index.mdx new file mode 100644 index 0000000000000..b79649eec4ec8 --- /dev/null +++ b/src/platforms/common/usage/distributed-tracing/index.mdx @@ -0,0 +1,34 @@ +--- +title: Distributed Tracing +sidebar_order: 40 +description: "Learn how to connect events across applications/services." +--- + +If the overall application landscape that want to observe with Sentry consists of more than just a single service or application, you might be interested in distributed tracing and what it can do for you. + +## What is Distributed Tracing? + +In the context of tracing events across a distributed system, distributed tracing acts as a powerful debugging tool. Imagine your application as a vast network of interconnected parts. This can mean a lot of things, for example that your system is spread across different servers, or simply that your application is split into different backend and frontend services, each potentially having their own technology stack. + +When an error or performance issue occurs, it can be challenging to pinpoint the root cause due to the complexity of a system. Distributed tracing helps you follow the path of an event as it travels through this intricate web, recording every step it takes. By examining these traces, you can reconstruct the sequence of events leading up to the event of interest, identify the specific components involved, and understand their interactions. This detailed visibility enables you to diagnose and resolve issues more effectively, ultimately improving the reliability and performance of your distributed system. + +## Basic Example +Here's an example showing a distributed trace in Sentry: + +![A full distributed trace in Sentry](distributed-trace-in-sentry.png) + +This distributed trace shows a Vue app's `pageload` making a request to a Python backend, which then calls the `/api` endpoint of a Ruby microservice. + +What happens in the background is that Sentry uses reads and further propagates two HTTP headers between your applications: + +- `sentry-trace` +- `baggage` + +When you also run JavaScript applications in your distributed system, you have to make sure that those two headers are added to your CORS allowlist and won't be blocked or stripped by your proxy servers, gateways, or firewalls. + + +## How to Use Distributed Tracing? + + + +But remember, in order to propagate trace information through your whole distributed system, you have to use Sentry in all of the involved services and applications. Take a look at the respective SDK documentation, to find out how distributed tracing can be enabled for each of them. diff --git a/src/platforms/common/usage/distributed-tracing/limiting-trace-propagation.mdx b/src/platforms/common/usage/distributed-tracing/limiting-trace-propagation.mdx new file mode 100644 index 0000000000000..077dbb494969f --- /dev/null +++ b/src/platforms/common/usage/distributed-tracing/limiting-trace-propagation.mdx @@ -0,0 +1,15 @@ +--- +title: Limiting Trace Propagation +sidebar_order: 100 +description: "" +supported: + - python +--- + +By default, trace information (`sentry-trace` and `baggage` headers) will be added to all outgoing HTTP requests. If you want to limit to the URLs where trace information is added, you can specify a `trace_propagation_targets` option: + + + +In the example above, trace information will be added to all requests to URLs that contain `"https://myproject.org"` and to all URLs of all sub domains of `otherservice.org` like `https://api.otherservice.org/something/` or `https://payment.otherservice.org/something/`. + +See Tracing Options docs for more information about the `trace_propagation_targets` option. diff --git a/src/platforms/javascript/common/distributed-tracing/index.mdx b/src/platforms/javascript/common/distributed-tracing/index.mdx deleted file mode 100644 index a23fda7108ed7..0000000000000 --- a/src/platforms/javascript/common/distributed-tracing/index.mdx +++ /dev/null @@ -1,28 +0,0 @@ ---- -title: Distributed Tracing -sidebar_order: 40 -description: "Learn how to connect frontend and backend transactions." -redirect_from: - - /platforms/javascript/performance/connect-services/ - - /platforms/javascript/guides/angular/performance/connect-services/ - - /platforms/javascript/guides/capacitor/performance/connect-services/ - - /platforms/javascript/guides/cordova/performance/connect-services/ - - /platforms/javascript/guides/electron/performance/connect-services/ - - /platforms/javascript/guides/ember/performance/connect-services/ - - /platforms/javascript/guides/gatsby/performance/connect-services/ - - /platforms/javascript/guides/nextjs/performance/connect-services/ - - /platforms/javascript/guides/react/performance/connect-services/ - - /platforms/javascript/guides/remix/performance/connect-services/ - - /platforms/javascript/guides/svelte/performance/connect-services/ - - /platforms/javascript/guides/sveltekit/performance/connect-services/ - - /platforms/javascript/guides/vue/performance/connect-services/ - - /platforms/javascript/guides/wasm/performance/connect-services/ -notSupported: - - javascript.cordova ---- - - - - - - diff --git a/src/platforms/python/common/distributed-tracing/index.mdx b/src/platforms/python/common/distributed-tracing/index.mdx deleted file mode 100644 index d10eda55d6ee1..0000000000000 --- a/src/platforms/python/common/distributed-tracing/index.mdx +++ /dev/null @@ -1,35 +0,0 @@ ---- -title: Distributed Tracing -sidebar_order: 40 -description: "Learn how to connect frontend and backend transactions." -redirect_from: - - /platforms/python/performance/connect-services/ - - /platforms/python/guides/aiohttp/performance/connect-services/ - - /platforms/python/guides/airflow/performance/connect-services/ - - /platforms/python/guides/arq/performance/connect-services/ - - /platforms/python/guides/aws-lambda/performance/connect-services/ - - /platforms/python/guides/bottle/performance/connect-services/ - - /platforms/python/guides/celery/performance/connect-services/ - - /platforms/python/guides/chalice/performance/connect-services/ - - /platforms/python/guides/django/performance/connect-services/ - - /platforms/python/guides/falcon/performance/connect-services/ - - /platforms/python/guides/fastapi/performance/connect-services/ - - /platforms/python/guides/flask/performance/connect-services/ - - /platforms/python/guides/gcp-function/performance/connect-services/ - - /platforms/python/guides/logging/performance/connect-services/ - - /platforms/python/guides/pyramid/performance/connect-services/ - - /platforms/python/guides/pyspark/performance/connect-services/ - - /platforms/python/guides/quart/performance/connect-services/ - - /platforms/python/guides/rq/performance/connect-services/ - - /platforms/python/guides/sanic/performance/connect-services/ - - /platforms/python/guides/serverless/performance/connect-services/ - - /platforms/python/guides/starlette/performance/connect-services/ - - /platforms/python/guides/tornado/performance/connect-services/ - - /platforms/python/guides/tryton/performance/connect-services/ ---- - - - - - - diff --git a/vercel.json b/vercel.json index 30fb6295137e9..721e2b8e334a0 100644 --- a/vercel.json +++ b/vercel.json @@ -495,6 +495,14 @@ { "source": "/platforms/([^/]*)/guides/([^/]*)/crons/troubleshooting-crons/", "destination": "/platforms/$1/guides/$2/crons/troubleshooting/" + }, + { + "source": "/platforms/([^/]*)/performance/connect-services/", + "destination": "/platforms/$1/usage/distributed-tracing/" + }, + { + "source": "/platforms/([^/]*)/guides/([^/]*)/performance/connect-services/", + "destination": "/platforms/$1/guides/$2/usage/distributed-tracing/" } ] } From 49851a55776d93c39eb4d315d292db6d7d73f9ed Mon Sep 17 00:00:00 2001 From: "getsantry[bot]" <66042841+getsantry[bot]@users.noreply.github.com> Date: Fri, 30 Jun 2023 07:06:58 +0000 Subject: [PATCH 108/116] style(lint): Auto commit lint changes --- .../distributed-tracing/custom-instrumentation/python.mdx | 5 ----- 1 file changed, 5 deletions(-) diff --git a/src/platform-includes/distributed-tracing/custom-instrumentation/python.mdx b/src/platform-includes/distributed-tracing/custom-instrumentation/python.mdx index 64ddbdd91262f..2096c3403f158 100644 --- a/src/platform-includes/distributed-tracing/custom-instrumentation/python.mdx +++ b/src/platform-includes/distributed-tracing/custom-instrumentation/python.mdx @@ -25,7 +25,6 @@ In this example, `get_incoming_headers_as_dict()` returns a dictionary that cont Sentry's `continue_trace()` function will extract the given headers, try to find the `sentry-trace` and `baggage` headers, and store them in memory for later use. - ## Inject Tracing Information to Outgoing Requests For distributed tracing to work, the two headers `sentry-trace` and `baggage`, must now also be added to outgoing requests. @@ -49,10 +48,6 @@ In this example, tracing information is propagated to the project running at `ht The two services are now connected with your custom distributed tracing implementation. - - - - ### Inject Tracing Information Into Rendered HTML To propagate tracing information into JavaScript running in rendered HTML you have to inject HTML `meta` tags for `sentry-trace` and `baggage` data into your rendered HTML. Here's an example: From 6c7a23869aa30765ae07302766cbcd2c3ec89d66 Mon Sep 17 00:00:00 2001 From: "getsantry[bot]" <66042841+getsantry[bot]@users.noreply.github.com> Date: Fri, 30 Jun 2023 07:06:59 +0000 Subject: [PATCH 109/116] style(lint): Auto commit lint changes --- src/platform-includes/distributed-tracing/how-to-use/python.mdx | 1 + 1 file changed, 1 insertion(+) diff --git a/src/platform-includes/distributed-tracing/how-to-use/python.mdx b/src/platform-includes/distributed-tracing/how-to-use/python.mdx index 1fe1f1214a423..59c549ecac78b 100644 --- a/src/platform-includes/distributed-tracing/how-to-use/python.mdx +++ b/src/platform-includes/distributed-tracing/how-to-use/python.mdx @@ -1,4 +1,5 @@ If you use the current version of our Python SDK, distributed tracing just works out of the box for the following frameworks: + - [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/) - [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/) - [Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/) From b48a0725ba0c0989cfd8c79f19b9625f87410778 Mon Sep 17 00:00:00 2001 From: "getsantry[bot]" <66042841+getsantry[bot]@users.noreply.github.com> Date: Fri, 30 Jun 2023 07:08:38 +0000 Subject: [PATCH 110/116] style(lint): Auto commit lint changes --- src/platforms/common/usage/distributed-tracing/index.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/platforms/common/usage/distributed-tracing/index.mdx b/src/platforms/common/usage/distributed-tracing/index.mdx index b79649eec4ec8..e073fab461ecf 100644 --- a/src/platforms/common/usage/distributed-tracing/index.mdx +++ b/src/platforms/common/usage/distributed-tracing/index.mdx @@ -13,6 +13,7 @@ In the context of tracing events across a distributed system, distributed tracin When an error or performance issue occurs, it can be challenging to pinpoint the root cause due to the complexity of a system. Distributed tracing helps you follow the path of an event as it travels through this intricate web, recording every step it takes. By examining these traces, you can reconstruct the sequence of events leading up to the event of interest, identify the specific components involved, and understand their interactions. This detailed visibility enables you to diagnose and resolve issues more effectively, ultimately improving the reliability and performance of your distributed system. ## Basic Example + Here's an example showing a distributed trace in Sentry: ![A full distributed trace in Sentry](distributed-trace-in-sentry.png) @@ -26,7 +27,6 @@ What happens in the background is that Sentry uses reads and further propagates When you also run JavaScript applications in your distributed system, you have to make sure that those two headers are added to your CORS allowlist and won't be blocked or stripped by your proxy servers, gateways, or firewalls. - ## How to Use Distributed Tracing? From 1d104d1ae7042ad00796ed81a6e3610d62ef630d Mon Sep 17 00:00:00 2001 From: "getsantry[bot]" <66042841+getsantry[bot]@users.noreply.github.com> Date: Fri, 30 Jun 2023 07:09:08 +0000 Subject: [PATCH 111/116] style(lint): Auto commit lint changes From 6a5e6ab47941ea821d57e684af5e3f5377f3e41c Mon Sep 17 00:00:00 2001 From: Stephanie Anderson Date: Fri, 30 Jun 2023 14:50:15 +0200 Subject: [PATCH 112/116] further updates on TwP --- .../approach/sdk-docs/write-performance.mdx | 6 ----- .../javascript.mdx | 0 .../python.mdx | 0 .../_default.mdx | 0 .../javascript.mdx | 0 .../javascript.mdx | 0 .../custom-instrumentation/javascript.mdx | 10 ++----- .../custom-instrumentation/python.mdx | 11 +++++--- .../how-to-use/python.bottle.mdx | 2 +- .../how-to-use/python.django.mdx | 2 +- .../how-to-use/python.falcon.mdx | 2 +- .../how-to-use/python.fastapi.mdx | 2 +- .../how-to-use/python.flask.mdx | 2 +- .../distributed-tracing/how-to-use/python.mdx | 18 ++++++------- .../how-to-use/python.pyramid.mdx | 2 +- .../how-to-use/python.quart.mdx | 2 +- .../how-to-use/python.starlette.mdx | 2 +- .../how-to-use/python.tornado.mdx | 2 +- .../_default.mdx | 0 .../limiting-traces/python.mdx | 2 +- .../getting-started-primer/python.flask.mdx | 2 -- .../apple/common/configuration/swizzling.mdx | 4 +-- .../common/configuration/sampling.mdx | 4 +-- .../common/performance/connect-services.mdx | 26 ------------------- src/platforms/common/performance/index.mdx | 2 +- .../limiting-trace-propagation.mdx | 2 +- 26 files changed, 34 insertions(+), 71 deletions(-) rename src/platform-includes/distributed-tracing/{instrumentation => TODO-INTEGRATE-instrumentation}/automatic-instrumentation-configuration/javascript.mdx (100%) rename src/platform-includes/distributed-tracing/{instrumentation => TODO-INTEGRATE-instrumentation}/automatic-instrumentation-configuration/python.mdx (100%) rename src/platform-includes/distributed-tracing/{custom-instrumentation => TODO-INTEGRATE-instrumentation/automatic-instrumentation-intro}/_default.mdx (100%) rename src/platform-includes/distributed-tracing/{instrumentation => TODO-INTEGRATE-instrumentation}/automatic-instrumentation-intro/javascript.mdx (100%) rename src/platform-includes/distributed-tracing/{set-up-distributed-tracing-configuration => TODO-INTEGRATE-set-up-distributed-tracing-configuration}/javascript.mdx (100%) delete mode 100644 src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/_default.mdx delete mode 100644 src/platforms/common/performance/connect-services.mdx diff --git a/src/docs/contributing/approach/sdk-docs/write-performance.mdx b/src/docs/contributing/approach/sdk-docs/write-performance.mdx index 13a24656af5f2..87fcae3d3fd39 100644 --- a/src/docs/contributing/approach/sdk-docs/write-performance.mdx +++ b/src/docs/contributing/approach/sdk-docs/write-performance.mdx @@ -66,8 +66,6 @@ If any of the above files are not applicable to your platform, find the ``, then add a code sample `/src/platform-includes/performance/connect-errors-spans/`. -If the platform supports distributed tracing using custom instrumentation, add the SDK to the appropriate `` and create an appropriate file at `src/platform-includes/performance/distributed-tracing`. - ### Automatic Instrumentation This page does not use common content. It covers what instrumentation is automatic when tracing is enabled for this SDK. @@ -82,10 +80,6 @@ This file is `troubleshooting-performance.mdx`. It explains corner cases and how 2. Add an example to `src/platform-includes/performance/control-data-truncation/` -### Connecting Services - -This page does not currently use common content. It covers an example of how to connect frontend and backend services. In future, we may determine that it's useful to expand the content beyond the JS-specific focus. - ### Sampling Guidelines TBD. diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx b/src/platform-includes/distributed-tracing/TODO-INTEGRATE-instrumentation/automatic-instrumentation-configuration/javascript.mdx similarity index 100% rename from src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/javascript.mdx rename to src/platform-includes/distributed-tracing/TODO-INTEGRATE-instrumentation/automatic-instrumentation-configuration/javascript.mdx diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx b/src/platform-includes/distributed-tracing/TODO-INTEGRATE-instrumentation/automatic-instrumentation-configuration/python.mdx similarity index 100% rename from src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-configuration/python.mdx rename to src/platform-includes/distributed-tracing/TODO-INTEGRATE-instrumentation/automatic-instrumentation-configuration/python.mdx diff --git a/src/platform-includes/distributed-tracing/custom-instrumentation/_default.mdx b/src/platform-includes/distributed-tracing/TODO-INTEGRATE-instrumentation/automatic-instrumentation-intro/_default.mdx similarity index 100% rename from src/platform-includes/distributed-tracing/custom-instrumentation/_default.mdx rename to src/platform-includes/distributed-tracing/TODO-INTEGRATE-instrumentation/automatic-instrumentation-intro/_default.mdx diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/javascript.mdx b/src/platform-includes/distributed-tracing/TODO-INTEGRATE-instrumentation/automatic-instrumentation-intro/javascript.mdx similarity index 100% rename from src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/javascript.mdx rename to src/platform-includes/distributed-tracing/TODO-INTEGRATE-instrumentation/automatic-instrumentation-intro/javascript.mdx diff --git a/src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/javascript.mdx b/src/platform-includes/distributed-tracing/TODO-INTEGRATE-set-up-distributed-tracing-configuration/javascript.mdx similarity index 100% rename from src/platform-includes/distributed-tracing/set-up-distributed-tracing-configuration/javascript.mdx rename to src/platform-includes/distributed-tracing/TODO-INTEGRATE-set-up-distributed-tracing-configuration/javascript.mdx diff --git a/src/platform-includes/distributed-tracing/custom-instrumentation/javascript.mdx b/src/platform-includes/distributed-tracing/custom-instrumentation/javascript.mdx index 25de881dc2414..36ef0611ee4fe 100644 --- a/src/platform-includes/distributed-tracing/custom-instrumentation/javascript.mdx +++ b/src/platform-includes/distributed-tracing/custom-instrumentation/javascript.mdx @@ -1,12 +1,6 @@ - +To set it up manually, all you have to do is to make sure your application extracts incoming headers and to set those headers again when making an outgoing request within your application. To enable distributed tracing, add the `BrowserTracing` integration to your `Sentry.init` options, as described in the Performance Automatic Instrumentation docs. The [Next.js](/platforms/javascript/guides/nextjs/) and [SvelteKit](/platforms/javascript/guides/sveltekit/) SDKs include this integration by default. diff --git a/src/platform-includes/distributed-tracing/custom-instrumentation/python.mdx b/src/platform-includes/distributed-tracing/custom-instrumentation/python.mdx index 2096c3403f158..eb3e5fe137d52 100644 --- a/src/platform-includes/distributed-tracing/custom-instrumentation/python.mdx +++ b/src/platform-includes/distributed-tracing/custom-instrumentation/python.mdx @@ -1,8 +1,8 @@ -On this page you will learn how to manually propagate trace information into and out of your Python application. Please note, that you do not need to do this manually, if you use one of our supported frameworks, or you have our performance monitoring feature turned on. +On this page you will learn how to manually propagate trace information into and out of your Python application. Please note, that you do not need to do this manually, if you [use one of our supported frameworks](/platforms/python/usage/distributed-tracing/#how-to-use-distributed-tracing), or you have our performance monitoring feature turned on. To set it up manually, all you have to do is to make sure your application extracts incoming headers and to set those headers again when making an outgoing request within your application. -## Extract Incoming Tracing Information +## Step 1) Extract Incoming Tracing Information Incoming tracing information has to be extracted and stored in memory for later use. Sentry provides the `continue_trace()` function to help you with this. Incoming tracing information can come from different places: @@ -25,9 +25,12 @@ In this example, `get_incoming_headers_as_dict()` returns a dictionary that cont Sentry's `continue_trace()` function will extract the given headers, try to find the `sentry-trace` and `baggage` headers, and store them in memory for later use. -## Inject Tracing Information to Outgoing Requests +## Step 2) Inject Tracing Information to Outgoing Requests -For distributed tracing to work, the two headers `sentry-trace` and `baggage`, must now also be added to outgoing requests. +For distributed tracing to work, the two headers `sentry-trace` and `baggage`, must now also be added to outgoing requests. If you pregenerate HTML on the server-side, you might want to take a look at option 2 as well, which describes how to pass on tracing information through HTML meta tags. + + +### Inject Tracing Information Into HTTP Requests If you are sending outgoing HTTP requests with [Requests](https://requests.readthedocs.io/en/latest/), [AIOHTTP](https://docs.aiohttp.org/en/stable/), the low level [http.client](https://docs.python.org/3/library/http.client.html), or [httplib](https://docs.python.org/2/library/httplib.html) on Python 2, this tracing information is automatically added to outgoing requests. diff --git a/src/platform-includes/distributed-tracing/how-to-use/python.bottle.mdx b/src/platform-includes/distributed-tracing/how-to-use/python.bottle.mdx index a34bc0fe4db7d..22488c7e4f9b9 100644 --- a/src/platform-includes/distributed-tracing/how-to-use/python.bottle.mdx +++ b/src/platform-includes/distributed-tracing/how-to-use/python.bottle.mdx @@ -1,3 +1,3 @@ If you use the current version of our Python SDK, distributed tracing just works out of the box. No additional configuration is required. -If you however use version `1.25.x` or below, you need to have our "Performance Monitoring" feature enabled for distributed tracing to work. Learn more in Set Up Performance. +If you however use version `1.25.x` or below, you need to have our performance monitoring feature enabled for distributed tracing to work. diff --git a/src/platform-includes/distributed-tracing/how-to-use/python.django.mdx b/src/platform-includes/distributed-tracing/how-to-use/python.django.mdx index a34bc0fe4db7d..22488c7e4f9b9 100644 --- a/src/platform-includes/distributed-tracing/how-to-use/python.django.mdx +++ b/src/platform-includes/distributed-tracing/how-to-use/python.django.mdx @@ -1,3 +1,3 @@ If you use the current version of our Python SDK, distributed tracing just works out of the box. No additional configuration is required. -If you however use version `1.25.x` or below, you need to have our "Performance Monitoring" feature enabled for distributed tracing to work. Learn more in Set Up Performance. +If you however use version `1.25.x` or below, you need to have our performance monitoring feature enabled for distributed tracing to work. diff --git a/src/platform-includes/distributed-tracing/how-to-use/python.falcon.mdx b/src/platform-includes/distributed-tracing/how-to-use/python.falcon.mdx index a34bc0fe4db7d..22488c7e4f9b9 100644 --- a/src/platform-includes/distributed-tracing/how-to-use/python.falcon.mdx +++ b/src/platform-includes/distributed-tracing/how-to-use/python.falcon.mdx @@ -1,3 +1,3 @@ If you use the current version of our Python SDK, distributed tracing just works out of the box. No additional configuration is required. -If you however use version `1.25.x` or below, you need to have our "Performance Monitoring" feature enabled for distributed tracing to work. Learn more in Set Up Performance. +If you however use version `1.25.x` or below, you need to have our performance monitoring feature enabled for distributed tracing to work. diff --git a/src/platform-includes/distributed-tracing/how-to-use/python.fastapi.mdx b/src/platform-includes/distributed-tracing/how-to-use/python.fastapi.mdx index a34bc0fe4db7d..22488c7e4f9b9 100644 --- a/src/platform-includes/distributed-tracing/how-to-use/python.fastapi.mdx +++ b/src/platform-includes/distributed-tracing/how-to-use/python.fastapi.mdx @@ -1,3 +1,3 @@ If you use the current version of our Python SDK, distributed tracing just works out of the box. No additional configuration is required. -If you however use version `1.25.x` or below, you need to have our "Performance Monitoring" feature enabled for distributed tracing to work. Learn more in Set Up Performance. +If you however use version `1.25.x` or below, you need to have our performance monitoring feature enabled for distributed tracing to work. diff --git a/src/platform-includes/distributed-tracing/how-to-use/python.flask.mdx b/src/platform-includes/distributed-tracing/how-to-use/python.flask.mdx index a34bc0fe4db7d..22488c7e4f9b9 100644 --- a/src/platform-includes/distributed-tracing/how-to-use/python.flask.mdx +++ b/src/platform-includes/distributed-tracing/how-to-use/python.flask.mdx @@ -1,3 +1,3 @@ If you use the current version of our Python SDK, distributed tracing just works out of the box. No additional configuration is required. -If you however use version `1.25.x` or below, you need to have our "Performance Monitoring" feature enabled for distributed tracing to work. Learn more in Set Up Performance. +If you however use version `1.25.x` or below, you need to have our performance monitoring feature enabled for distributed tracing to work. diff --git a/src/platform-includes/distributed-tracing/how-to-use/python.mdx b/src/platform-includes/distributed-tracing/how-to-use/python.mdx index 59c549ecac78b..c1b8c12eb653d 100644 --- a/src/platform-includes/distributed-tracing/how-to-use/python.mdx +++ b/src/platform-includes/distributed-tracing/how-to-use/python.mdx @@ -1,13 +1,13 @@ If you use the current version of our Python SDK, distributed tracing just works out of the box for the following frameworks: -- [Django](/platforms/python/guides/django/distributed-tracing/instrumentation/automatic-instrumentation/) -- [FastAPI](/platforms/python/guides/fastapi/distributed-tracing/instrumentation/automatic-instrumentation/) -- [Flask](/platforms/python/guides/flask/distributed-tracing/instrumentation/automatic-instrumentation/) -- [Bottle](/platforms/python/guides/bottle/distributed-tracing/instrumentation/automatic-instrumentation/) -- [Falcon](/platforms/python/guides/falcon/distributed-tracing/instrumentation/automatic-instrumentation/) -- [Pyramid](/platforms/python/guides/pyramid/distributed-tracing/instrumentation/automatic-instrumentation/) -- [Quart](/platforms/python/guides/quart/distributed-tracing/instrumentation/automatic-instrumentation/) -- [Starlette](/platforms/python/guides/starlette/distributed-tracing/instrumentation/automatic-instrumentation/) -- [Tornado](/platforms/python/guides/tornado/distributed-tracing/instrumentation/automatic-instrumentation/) +- [Django](/platforms/python/guides/django/usage/distributed-tracing/#how-to-use-distributed-tracing) +- [FastAPI](/platforms/python/guides/fastapi/usage/distributed-tracing/#how-to-use-distributed-tracing) +- [Flask](/platforms/python/guides/flask/usage/distributed-tracing/#how-to-use-distributed-tracing) +- [Bottle](/platforms/python/guides/bottle/usage/distributed-tracing/#how-to-use-distributed-tracing) +- [Falcon](/platforms/python/guides/falcon/usage/distributed-tracing/#how-to-use-distributed-tracing) +- [Pyramid](/platforms/python/guides/pyramid/usage/distributed-tracing/#how-to-use-distributed-tracing) +- [Quart](/platforms/python/guides/quart/usage/distributed-tracing/#how-to-use-distributed-tracing) +- [Starlette](/platforms/python/guides/starlette/usage/distributed-tracing/#how-to-use-distributed-tracing) +- [Tornado](/platforms/python/guides/tornado/usage/distributed-tracing/#how-to-use-distributed-tracing) If you however use version `1.25.x` or below, you need to have our performance monitoring feature enabled for distributed tracing to work. However, if you do not want to activate performance monitoring, you can also setup a custom instrumentation. diff --git a/src/platform-includes/distributed-tracing/how-to-use/python.pyramid.mdx b/src/platform-includes/distributed-tracing/how-to-use/python.pyramid.mdx index a34bc0fe4db7d..22488c7e4f9b9 100644 --- a/src/platform-includes/distributed-tracing/how-to-use/python.pyramid.mdx +++ b/src/platform-includes/distributed-tracing/how-to-use/python.pyramid.mdx @@ -1,3 +1,3 @@ If you use the current version of our Python SDK, distributed tracing just works out of the box. No additional configuration is required. -If you however use version `1.25.x` or below, you need to have our "Performance Monitoring" feature enabled for distributed tracing to work. Learn more in Set Up Performance. +If you however use version `1.25.x` or below, you need to have our performance monitoring feature enabled for distributed tracing to work. diff --git a/src/platform-includes/distributed-tracing/how-to-use/python.quart.mdx b/src/platform-includes/distributed-tracing/how-to-use/python.quart.mdx index a34bc0fe4db7d..22488c7e4f9b9 100644 --- a/src/platform-includes/distributed-tracing/how-to-use/python.quart.mdx +++ b/src/platform-includes/distributed-tracing/how-to-use/python.quart.mdx @@ -1,3 +1,3 @@ If you use the current version of our Python SDK, distributed tracing just works out of the box. No additional configuration is required. -If you however use version `1.25.x` or below, you need to have our "Performance Monitoring" feature enabled for distributed tracing to work. Learn more in Set Up Performance. +If you however use version `1.25.x` or below, you need to have our performance monitoring feature enabled for distributed tracing to work. diff --git a/src/platform-includes/distributed-tracing/how-to-use/python.starlette.mdx b/src/platform-includes/distributed-tracing/how-to-use/python.starlette.mdx index a34bc0fe4db7d..22488c7e4f9b9 100644 --- a/src/platform-includes/distributed-tracing/how-to-use/python.starlette.mdx +++ b/src/platform-includes/distributed-tracing/how-to-use/python.starlette.mdx @@ -1,3 +1,3 @@ If you use the current version of our Python SDK, distributed tracing just works out of the box. No additional configuration is required. -If you however use version `1.25.x` or below, you need to have our "Performance Monitoring" feature enabled for distributed tracing to work. Learn more in Set Up Performance. +If you however use version `1.25.x` or below, you need to have our performance monitoring feature enabled for distributed tracing to work. diff --git a/src/platform-includes/distributed-tracing/how-to-use/python.tornado.mdx b/src/platform-includes/distributed-tracing/how-to-use/python.tornado.mdx index a34bc0fe4db7d..22488c7e4f9b9 100644 --- a/src/platform-includes/distributed-tracing/how-to-use/python.tornado.mdx +++ b/src/platform-includes/distributed-tracing/how-to-use/python.tornado.mdx @@ -1,3 +1,3 @@ If you use the current version of our Python SDK, distributed tracing just works out of the box. No additional configuration is required. -If you however use version `1.25.x` or below, you need to have our "Performance Monitoring" feature enabled for distributed tracing to work. Learn more in Set Up Performance. +If you however use version `1.25.x` or below, you need to have our performance monitoring feature enabled for distributed tracing to work. diff --git a/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/_default.mdx b/src/platform-includes/distributed-tracing/instrumentation/automatic-instrumentation-intro/_default.mdx deleted file mode 100644 index e69de29bb2d1d..0000000000000 diff --git a/src/platform-includes/distributed-tracing/limiting-traces/python.mdx b/src/platform-includes/distributed-tracing/limiting-traces/python.mdx index 02b20df5b4139..63e189d10cd0e 100644 --- a/src/platform-includes/distributed-tracing/limiting-traces/python.mdx +++ b/src/platform-includes/distributed-tracing/limiting-traces/python.mdx @@ -5,7 +5,7 @@ sentry_sdk.init( dsn="___PUBLIC_DSN___", trace_propagation_targets=[ "https://myproject.org", - r"https://.*\.otherservice.org/.*", + "https://.*\.otherservice.org/.*", ], # ... ) diff --git a/src/platform-includes/getting-started-primer/python.flask.mdx b/src/platform-includes/getting-started-primer/python.flask.mdx index 356444610e2fb..30ef372a0bd42 100644 --- a/src/platform-includes/getting-started-primer/python.flask.mdx +++ b/src/platform-includes/getting-started-primer/python.flask.mdx @@ -1,7 +1,5 @@ -Sentry's Flask integration enables automatic reporting of errors and exceptions. - Our Python SDK will install the Flask integration for all of your apps. It hooks into Flask’s signals, not anything on the app object. Each request has a separate scope. Changes to the scope within a view, for example setting a tag, will only apply to events sent as part of the request being handled. diff --git a/src/platforms/apple/common/configuration/swizzling.mdx b/src/platforms/apple/common/configuration/swizzling.mdx index 3dba02bb11afd..a465c38cf777b 100644 --- a/src/platforms/apple/common/configuration/swizzling.mdx +++ b/src/platforms/apple/common/configuration/swizzling.mdx @@ -20,7 +20,7 @@ The Cocoa SDK uses [swizzling](https://nshipster.com/method-swizzling/) to provi - Auto instrumentation for Core Data operations -- +- Automatically added sentry-trace header to HTTP requests for distributed tracing @@ -47,7 +47,7 @@ The Cocoa SDK uses [swizzling](https://nshipster.com/method-swizzling/) to provi - Auto instrumentation for Core Data operations -- +- Automatically added sentry-trace header to HTTP requests for distributed tracing diff --git a/src/platforms/common/configuration/sampling.mdx b/src/platforms/common/configuration/sampling.mdx index abf82b268cee9..f1afa0af1166c 100644 --- a/src/platforms/common/configuration/sampling.mdx +++ b/src/platforms/common/configuration/sampling.mdx @@ -111,13 +111,13 @@ Whatever a transaction's sampling decision, that decision will be passed to its -(See Connecting Services for more about how that propagation is done.) +(See Connecting Services for more about how that propagation is done.) -(See [Connecting Services](/platforms/php/guides/laravel/performance/connect-services/) for more about how that propagation is done.) +(See Connecting Services for more about how that propagation is done.) diff --git a/src/platforms/common/performance/connect-services.mdx b/src/platforms/common/performance/connect-services.mdx deleted file mode 100644 index 3e84e775e5163..0000000000000 --- a/src/platforms/common/performance/connect-services.mdx +++ /dev/null @@ -1,26 +0,0 @@ ---- -title: Connect Services -sidebar_order: 40 -description: "Learn how to connect backend and frontend transactions." -notSupported: - - javascript - - python ---- - -When tracing is enabled, the SDK will attach an outgoing header called `sentry-trace` to requests. This depends on the out of the box integrations we provide, but you can expect the header `sentry-trace` to be present. If it's not, you can manually add `sentry-trace` headers to any requests by learning more about [its structure](https://develop.sentry.dev/sdk/performance/#header-sentry-trace). - -SDKs with performance monitoring support listen to incoming requests and typically automatically pick up the incoming `sentry-trace` header to continue the trace (with the same `trace-id`) from there, connecting backend and frontend transactions into a single coherent trace using the `trace_id` value. Depending on the circumstance, this ID is transmitted either in a request header or in an HTML `` tag. - -All your transactions that have the same `trace-id` are connected. Linking transactions in this way makes it possible to navigate among them in [sentry.io](https://sentry.io) to better understand how the different parts of your system are affecting one another. You can learn more about this model in our [Distributed Tracing](/product/sentry-basics/tracing/distributed-tracing/) docs. - - - -If the instrumentation you're using doesn't automatically pick up the `sentry-trace` header, you can also continue a trace manually by using the `continueFromHeaders` function on a `Transaction`. Learn more about this in our [Transaction Interface](https://develop.sentry.dev/sdk/performance/#new-span-and-transaction-classes) documentation. - - - - - - - - diff --git a/src/platforms/common/performance/index.mdx b/src/platforms/common/performance/index.mdx index bcbf45ee96975..e72561bd3762e 100644 --- a/src/platforms/common/performance/index.mdx +++ b/src/platforms/common/performance/index.mdx @@ -104,7 +104,7 @@ If you leave your sample rate at `1.0`, a transaction will be sent every time a - + ## Connecting Services diff --git a/src/platforms/common/usage/distributed-tracing/limiting-trace-propagation.mdx b/src/platforms/common/usage/distributed-tracing/limiting-trace-propagation.mdx index 077dbb494969f..28b8c21ae821c 100644 --- a/src/platforms/common/usage/distributed-tracing/limiting-trace-propagation.mdx +++ b/src/platforms/common/usage/distributed-tracing/limiting-trace-propagation.mdx @@ -12,4 +12,4 @@ By default, trace information (`sentry-trace` and `baggage` headers) will be add In the example above, trace information will be added to all requests to URLs that contain `"https://myproject.org"` and to all URLs of all sub domains of `otherservice.org` like `https://api.otherservice.org/something/` or `https://payment.otherservice.org/something/`. -See Tracing Options docs for more information about the `trace_propagation_targets` option. +See our config options documentation for more information about the `trace_propagation_targets` option. From 59525b2730f483afe700c1e30d874cb16583b3e9 Mon Sep 17 00:00:00 2001 From: "getsantry[bot]" <66042841+getsantry[bot]@users.noreply.github.com> Date: Fri, 30 Jun 2023 12:53:03 +0000 Subject: [PATCH 113/116] style(lint): Auto commit lint changes --- .../distributed-tracing/custom-instrumentation/python.mdx | 1 - 1 file changed, 1 deletion(-) diff --git a/src/platform-includes/distributed-tracing/custom-instrumentation/python.mdx b/src/platform-includes/distributed-tracing/custom-instrumentation/python.mdx index eb3e5fe137d52..c62574157a0ea 100644 --- a/src/platform-includes/distributed-tracing/custom-instrumentation/python.mdx +++ b/src/platform-includes/distributed-tracing/custom-instrumentation/python.mdx @@ -29,7 +29,6 @@ Sentry's `continue_trace()` function will extract the given headers, try to find For distributed tracing to work, the two headers `sentry-trace` and `baggage`, must now also be added to outgoing requests. If you pregenerate HTML on the server-side, you might want to take a look at option 2 as well, which describes how to pass on tracing information through HTML meta tags. - ### Inject Tracing Information Into HTTP Requests If you are sending outgoing HTTP requests with [Requests](https://requests.readthedocs.io/en/latest/), [AIOHTTP](https://docs.aiohttp.org/en/stable/), the low level [http.client](https://docs.python.org/3/library/http.client.html), or [httplib](https://docs.python.org/2/library/httplib.html) on Python 2, this tracing information is automatically added to outgoing requests. From 5f205acb476637ee502152ba4ebdc884c1944338 Mon Sep 17 00:00:00 2001 From: Stephanie Anderson Date: Fri, 30 Jun 2023 15:01:55 +0200 Subject: [PATCH 114/116] adapt link text --- src/platforms/common/configuration/sampling.mdx | 4 ++-- src/platforms/common/performance/index.mdx | 10 ---------- .../distributed-tracing/limiting-trace-propagation.mdx | 2 +- .../node/guides/express/performance/index.mdx | 4 ---- .../guides/laravel/performance/distributed-tracing.mdx | 2 +- 5 files changed, 4 insertions(+), 18 deletions(-) diff --git a/src/platforms/common/configuration/sampling.mdx b/src/platforms/common/configuration/sampling.mdx index f1afa0af1166c..11ea131701628 100644 --- a/src/platforms/common/configuration/sampling.mdx +++ b/src/platforms/common/configuration/sampling.mdx @@ -111,13 +111,13 @@ Whatever a transaction's sampling decision, that decision will be passed to its -(See Connecting Services for more about how that propagation is done.) +(See Distributed Tracing for more about how that propagation is done.) -(See Connecting Services for more about how that propagation is done.) +(See Distributed Tracing for more about how that propagation is done.) diff --git a/src/platforms/common/performance/index.mdx b/src/platforms/common/performance/index.mdx index e72561bd3762e..7cdaca8a6b59a 100644 --- a/src/platforms/common/performance/index.mdx +++ b/src/platforms/common/performance/index.mdx @@ -102,16 +102,6 @@ If you leave your sample rate at `1.0`, a transaction will be sent every time a - - - - -## Connecting Services - -If you are also using Performance Monitoring for [JavaScript](/platforms/javascript/performance/), you can connect the frontend and the backend service by configuring [Distributed Tracing](/platforms/javascript/distributed-tracing/). - - - `@sentry/react` exports a `withProfiler` higher order component that can be used to capture React related spans for specific React components. diff --git a/src/platforms/common/usage/distributed-tracing/limiting-trace-propagation.mdx b/src/platforms/common/usage/distributed-tracing/limiting-trace-propagation.mdx index 28b8c21ae821c..8705bd17b5d3a 100644 --- a/src/platforms/common/usage/distributed-tracing/limiting-trace-propagation.mdx +++ b/src/platforms/common/usage/distributed-tracing/limiting-trace-propagation.mdx @@ -8,7 +8,7 @@ supported: By default, trace information (`sentry-trace` and `baggage` headers) will be added to all outgoing HTTP requests. If you want to limit to the URLs where trace information is added, you can specify a `trace_propagation_targets` option: - + In the example above, trace information will be added to all requests to URLs that contain `"https://myproject.org"` and to all URLs of all sub domains of `otherservice.org` like `https://api.otherservice.org/something/` or `https://payment.otherservice.org/something/`. diff --git a/src/platforms/node/guides/express/performance/index.mdx b/src/platforms/node/guides/express/performance/index.mdx index 1a97ebc8331d5..0472c02b297f8 100644 --- a/src/platforms/node/guides/express/performance/index.mdx +++ b/src/platforms/node/guides/express/performance/index.mdx @@ -128,7 +128,3 @@ app.get("/success", function successHandler(req, res) { res.status(200).end(); }); ``` - -## Connecting Services - -If you are also using Performance Monitoring for [JavaScript](/platforms/javascript/performance/), you can connect the frontend and the backend service by configuring [Distributed Tracing](/platforms/javascript/distributed-tracing/). diff --git a/src/platforms/php/guides/laravel/performance/distributed-tracing.mdx b/src/platforms/php/guides/laravel/performance/distributed-tracing.mdx index 155f282e7d907..dbfc0b00756ff 100644 --- a/src/platforms/php/guides/laravel/performance/distributed-tracing.mdx +++ b/src/platforms/php/guides/laravel/performance/distributed-tracing.mdx @@ -4,7 +4,7 @@ sidebar_order: 40 description: "Learn how to connect backend and frontend transactions." --- -If you're also using Performance Monitoring for [JavaScript](/platforms/javascript/performance/), you can use a helper function to continue the trace and propagate the trace context started from your backend in order to enable [Distributed Tracing](/platforms/javascript/distributed-tracing/). (The trace context contains additional trace-related data that is used for trace-based sampling.) +If you're also using Performance Monitoring for [JavaScript](/platforms/javascript/performance/), you can use a helper function to continue the trace and propagate the trace context started from your backend in order to enable [Distributed Tracing](/platforms/javascript/usage/distributed-tracing/). (The trace context contains additional trace-related data that is used for trace-based sampling.) Add the following line to your blade template rendering the `` of your page: ```php {filename:app.blade.php} From d49ec0bac41577a63dc69746daa0322ebe23dd07 Mon Sep 17 00:00:00 2001 From: Stephanie Anderson Date: Fri, 30 Jun 2023 15:22:35 +0200 Subject: [PATCH 115/116] fix broken links by disabling platforms --- src/platforms/common/usage/distributed-tracing/index.mdx | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/platforms/common/usage/distributed-tracing/index.mdx b/src/platforms/common/usage/distributed-tracing/index.mdx index e073fab461ecf..02b04af4b936d 100644 --- a/src/platforms/common/usage/distributed-tracing/index.mdx +++ b/src/platforms/common/usage/distributed-tracing/index.mdx @@ -2,6 +2,11 @@ title: Distributed Tracing sidebar_order: 40 description: "Learn how to connect events across applications/services." +notSupported: + - elixir + - javascript.cordova + - kotlin-multiplatform + - unreal --- If the overall application landscape that want to observe with Sentry consists of more than just a single service or application, you might be interested in distributed tracing and what it can do for you. From 4f6409191fb96fa48e486b09f997765fc42a377c Mon Sep 17 00:00:00 2001 From: "getsantry[bot]" <66042841+getsantry[bot]@users.noreply.github.com> Date: Fri, 30 Jun 2023 13:24:31 +0000 Subject: [PATCH 116/116] style(lint): Auto commit lint changes --- src/platforms/common/usage/distributed-tracing/index.mdx | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/platforms/common/usage/distributed-tracing/index.mdx b/src/platforms/common/usage/distributed-tracing/index.mdx index 02b04af4b936d..b0427abcc4fb0 100644 --- a/src/platforms/common/usage/distributed-tracing/index.mdx +++ b/src/platforms/common/usage/distributed-tracing/index.mdx @@ -3,10 +3,10 @@ title: Distributed Tracing sidebar_order: 40 description: "Learn how to connect events across applications/services." notSupported: - - elixir - - javascript.cordova - - kotlin-multiplatform - - unreal + - elixir + - javascript.cordova + - kotlin-multiplatform + - unreal --- If the overall application landscape that want to observe with Sentry consists of more than just a single service or application, you might be interested in distributed tracing and what it can do for you.