From 053259358f792f0539b98086f8f0bb01f9e63da4 Mon Sep 17 00:00:00 2001 From: JonasBa Date: Mon, 16 Sep 2024 14:13:48 -0400 Subject: [PATCH 01/11] docs(profiling): add new cont profiling page docs --- .../profiling/transaction-vs-continuous-profiling.mdx | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx diff --git a/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx b/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx new file mode 100644 index 0000000000000..2f9861cf743bd --- /dev/null +++ b/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx @@ -0,0 +1,8 @@ + +--- +title: "Transaction vs Continuous Profiling" +sidebar_order: 120 +description: "Continuous and transaction based profiling are two different modes with which you can profile the runtime of your application. They approach profiling from a different points of view with different tradeoffs. The documentation here serves as an explanation of those tradeoffs." +--- + +Nothing to see here From aa18b43445794fbdc941185872fe566c643d2183 Mon Sep 17 00:00:00 2001 From: JonasBa Date: Mon, 16 Sep 2024 16:33:12 -0400 Subject: [PATCH 02/11] ref(profiling) add doc page explaining the two modes --- .../transaction-vs-continuous-profiling.mdx | 48 +++++++++++++++++-- 1 file changed, 43 insertions(+), 5 deletions(-) diff --git a/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx b/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx index 2f9861cf743bd..a57e72ede70fa 100644 --- a/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx +++ b/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx @@ -1,8 +1,46 @@ - --- -title: "Transaction vs Continuous Profiling" -sidebar_order: 120 -description: "Continuous and transaction based profiling are two different modes with which you can profile the runtime of your application. They approach profiling from a different points of view with different tradeoffs. The documentation here serves as an explanation of those tradeoffs." +title: Transaction vs Continuous Profiling +sidebar_order: 140 +description: "Continuous and transaction based profiling are two different modes with which you can profile the runtime of your application. This document serves as an explanation as to why we did it and what it enables." --- -Nothing to see here + +We have released a new profiling mode called continuous profiling mode with fundamental differences from the previous transaction based profiling mode. This document serves as an explanation as to why we did so along with a couple of things that are helpful to know. + + +## A bit of context first + +Transaction based profiling was the first profiling mode supported at Sentry, it simply means that any code executed between Sentry.startTransaction and transaction.finish is subject to being profiled. In this mode, all profiles are attached to transactions (and are even sent as part of the same envelope). This has the benefit of automatically profiling parts of the application that are actually instrumented while requiring no extra effort. This approach however has drawback that continuous profiling aims to address, one of the most obvious ones being that profiles cannot exceed 30 second durations. + +In theory, transactions can be infinitely long as their duration does not impact payload size as start and end are represented by two timestamps. Profiles however are different, each stack sample that is collected by the profiler increases the payload size, which is why all Sentry SDKs had enforced a max profile duration of 30s. This limitation helps us safeguard from large payload that could otherwise harm your application performance. This unfortunately comes at the expense of limiting profiling capabilities as it means profiling is now no longer able to profile long running tasks like machine learning pipelines or build workflows. This feedback was the major driving force why we've introduced continuous profiling. + +The cap on max profile duration is however not the only drawback of transaction based profiling, another limitation of it is that the profiling data you collect, will only ever be as good as the instrumentation you have. In other words, if there are parts of your application that you did not instrument, the chance of you finding out that they are slowing down your application are near zero. + +To address these limitations, we have worked on a different profiling mode, one that does not impose constraints on profile durations and can surface parts of your application that might be slowing down your application even though you may not have instrumented them. + +## Continuous Profiling mode + +In countinuous profiling mode, the profiler runs continuously (no pun intended) and regularly flushes what we call profile "profile chunks" to the server, this enables us to extend profile durations and continuously profile your application. + +Continuous profiling mode is suitable for profiling long running workflows or processes that you want full visibility into, while the transaction based profiling is largely suitable for workflows where you want to limit profiling to only a subset of your application. + + +## SDK Differences + +Transaction based profiling was opaque from the SDK point of view with the SDK being in full control of when the profiler woulds start and stop based on the transactions it would generate. In continuous profiling mode, this is no longer true. Developers can now control when the profiler is started or stopped via new top level SDK methods. The exact method naming varies, but most SDKs that support continuous profiling now expose a top level Sentry.profiler that exposes a startProfiling and stopProfiling method (please see SDK docs for exact definitions). + +It is advisable that you call the startProfiling method right after the Sentry SDK is initialized so that you gain visibility at the earliest point in your application lifecycle. From then on, the profiler will keep collecting profiles and sending chunks to Sentry until stopProfiling is called. + +## Enabling transaction or continuous profiling mode + +Unfortunately, it is currently not possible to use both profiling modes at the same time, as they are mutually exlusive. Since the mode you intend on using depend on the SDK initialization arguments, it means that the profiling mode will have to be selected at the time the Sentry SDK is initialized. + +In order to enable continuous profiling mode, you should ensure that neither profileSampleRate or profilesSampler are set as the values to the Sentry.Init call. If either of those value are set, the SDK will default to transaction based profiling. When the SDK is configured for continuous profiling, the top level calls to start profiles will enable calls to the profiler. If the SDK is configured for transaction based profiling, then these calls will void and not trigger the profiler. + +Note that while the profiling mode cannot be changed at runtime, it is fine for different projects or applications to use different profiling modes, or to switch modes. + +## Differences in Product Experience + +The major difference in product experience when using continuous profiling is that you will be able to visualize a flamegraph for your entire application, which means you can now take a step back from the previous transaction based view and look at your application's runtime as a whole. This makes it easier to for you to prioritize the functions that are slowing down your entire application and not just one particular transaction. + +The product experience otherwise remains largely the same with entrypoints into profiling being supported from various parts of the performance product. From 89acac75ca021e0d6e687c2521f4c3169ce31b08 Mon Sep 17 00:00:00 2001 From: JonasBa Date: Mon, 16 Sep 2024 16:34:41 -0400 Subject: [PATCH 03/11] ref(docs) fix title caps --- .../profiling/transaction-vs-continuous-profiling.mdx | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx b/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx index a57e72ede70fa..7db6487c64229 100644 --- a/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx +++ b/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx @@ -8,7 +8,7 @@ description: "Continuous and transaction based profiling are two different modes We have released a new profiling mode called continuous profiling mode with fundamental differences from the previous transaction based profiling mode. This document serves as an explanation as to why we did so along with a couple of things that are helpful to know. -## A bit of context first +## A bit of historical context first Transaction based profiling was the first profiling mode supported at Sentry, it simply means that any code executed between Sentry.startTransaction and transaction.finish is subject to being profiled. In this mode, all profiles are attached to transactions (and are even sent as part of the same envelope). This has the benefit of automatically profiling parts of the application that are actually instrumented while requiring no extra effort. This approach however has drawback that continuous profiling aims to address, one of the most obvious ones being that profiles cannot exceed 30 second durations. @@ -18,14 +18,14 @@ The cap on max profile duration is however not the only drawback of transaction To address these limitations, we have worked on a different profiling mode, one that does not impose constraints on profile durations and can surface parts of your application that might be slowing down your application even though you may not have instrumented them. -## Continuous Profiling mode +## Continuous profiling mode In countinuous profiling mode, the profiler runs continuously (no pun intended) and regularly flushes what we call profile "profile chunks" to the server, this enables us to extend profile durations and continuously profile your application. Continuous profiling mode is suitable for profiling long running workflows or processes that you want full visibility into, while the transaction based profiling is largely suitable for workflows where you want to limit profiling to only a subset of your application. -## SDK Differences +## SDK differences Transaction based profiling was opaque from the SDK point of view with the SDK being in full control of when the profiler woulds start and stop based on the transactions it would generate. In continuous profiling mode, this is no longer true. Developers can now control when the profiler is started or stopped via new top level SDK methods. The exact method naming varies, but most SDKs that support continuous profiling now expose a top level Sentry.profiler that exposes a startProfiling and stopProfiling method (please see SDK docs for exact definitions). @@ -39,7 +39,7 @@ In order to enable continuous profiling mode, you should ensure that neither pro Note that while the profiling mode cannot be changed at runtime, it is fine for different projects or applications to use different profiling modes, or to switch modes. -## Differences in Product Experience +## Differences in product experience The major difference in product experience when using continuous profiling is that you will be able to visualize a flamegraph for your entire application, which means you can now take a step back from the previous transaction based view and look at your application's runtime as a whole. This makes it easier to for you to prioritize the functions that are slowing down your entire application and not just one particular transaction. From c06da60a512cb23b74929a3356bff57f5bc11f1b Mon Sep 17 00:00:00 2001 From: JonasBa Date: Tue, 17 Sep 2024 11:09:50 -0400 Subject: [PATCH 04/11] ref(profiling) add profiling doc section --- .../transaction-vs-continuous-profiling.mdx | 30 ++++++++++++++++++- 1 file changed, 29 insertions(+), 1 deletion(-) diff --git a/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx b/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx index 7db6487c64229..466fa7ac39fcb 100644 --- a/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx +++ b/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx @@ -35,7 +35,35 @@ It is advisable that you call the startProfiling method right after the Sentry S Unfortunately, it is currently not possible to use both profiling modes at the same time, as they are mutually exlusive. Since the mode you intend on using depend on the SDK initialization arguments, it means that the profiling mode will have to be selected at the time the Sentry SDK is initialized. -In order to enable continuous profiling mode, you should ensure that neither profileSampleRate or profilesSampler are set as the values to the Sentry.Init call. If either of those value are set, the SDK will default to transaction based profiling. When the SDK is configured for continuous profiling, the top level calls to start profiles will enable calls to the profiler. If the SDK is configured for transaction based profiling, then these calls will void and not trigger the profiler. +To enable continuous profiling mode, you should ensure that neither profileSampleRate or profilesSampler are set as the values to the Sentry.Init call. If either of those value are set, the SDK will default to transaction based profiling. When the SDK is configured for continuous profiling, the top level calls to start profiles will enable calls to the profiler. If the SDK is configured for transaction based profiling, then these calls will void and not trigger the profiler. + +Example of enabling continuous profiling in NodeJS + +```javascript +Sentry.Init({ + dsn: "___PUBLIC_DSN___", + integrations: [nodeProfilingIntegration()] +}) + +Sentry.profiler.startProfiling(); +``` + +If you wish to keep using transaction based profiling, then the options remain the same and you should either set profilesSampleRate or profilesSampler option on the SDK. + + +Example of enabling transaction based profiling in NodeJS + +```javascript +Sentry.Init({ + dsn: "___PUBLIC_DSN___", + profileSampleRate: 0.1 // profiles 10% of transactions + integrations: [nodeProfilingIntegration()] +}) + +const transaction = Sentry.startTransaction(); +//code executed between these two calls is subject to profiling +transaction.finish(); +``` Note that while the profiling mode cannot be changed at runtime, it is fine for different projects or applications to use different profiling modes, or to switch modes. From 4f50514f289707b37e2a06f54cbcca28bfc7d571 Mon Sep 17 00:00:00 2001 From: Jonas Date: Thu, 19 Sep 2024 16:41:06 -0400 Subject: [PATCH 05/11] Update docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx Co-authored-by: Liza Mock --- .../profiling/transaction-vs-continuous-profiling.mdx | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx b/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx index 466fa7ac39fcb..6757f5f6a8da8 100644 --- a/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx +++ b/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx @@ -4,9 +4,8 @@ sidebar_order: 140 description: "Continuous and transaction based profiling are two different modes with which you can profile the runtime of your application. This document serves as an explanation as to why we did it and what it enables." --- - -We have released a new profiling mode called continuous profiling mode with fundamental differences from the previous transaction based profiling mode. This document serves as an explanation as to why we did so along with a couple of things that are helpful to know. - +We've released a new profiling mode called **continuous profiling**. Read on to learn about the differences between transaction-based and continuous profiling mode. + ## A bit of historical context first From 3c0ab0ed1b62e9d0c5adacb29071115337938460 Mon Sep 17 00:00:00 2001 From: Jonas Date: Thu, 19 Sep 2024 16:41:18 -0400 Subject: [PATCH 06/11] Update docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx Co-authored-by: Liza Mock --- .../explore/profiling/transaction-vs-continuous-profiling.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx b/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx index 6757f5f6a8da8..ad39a1bafc2e8 100644 --- a/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx +++ b/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx @@ -1,7 +1,7 @@ --- title: Transaction vs Continuous Profiling sidebar_order: 140 -description: "Continuous and transaction based profiling are two different modes with which you can profile the runtime of your application. This document serves as an explanation as to why we did it and what it enables." +description: "Learn about the differences between continuous and transaction-based profiling." --- We've released a new profiling mode called **continuous profiling**. Read on to learn about the differences between transaction-based and continuous profiling mode. From 94c63ec93d5c9e7aa302673b55ebed9957835b24 Mon Sep 17 00:00:00 2001 From: Jonas Date: Thu, 19 Sep 2024 16:41:25 -0400 Subject: [PATCH 07/11] Update docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx Co-authored-by: Liza Mock --- .../explore/profiling/transaction-vs-continuous-profiling.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx b/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx index ad39a1bafc2e8..d876f60d7a56c 100644 --- a/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx +++ b/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx @@ -7,7 +7,7 @@ description: "Learn about the differences between continuous and transaction-bas We've released a new profiling mode called **continuous profiling**. Read on to learn about the differences between transaction-based and continuous profiling mode. -## A bit of historical context first +## Historical Context Transaction based profiling was the first profiling mode supported at Sentry, it simply means that any code executed between Sentry.startTransaction and transaction.finish is subject to being profiled. In this mode, all profiles are attached to transactions (and are even sent as part of the same envelope). This has the benefit of automatically profiling parts of the application that are actually instrumented while requiring no extra effort. This approach however has drawback that continuous profiling aims to address, one of the most obvious ones being that profiles cannot exceed 30 second durations. From 34390409539b9b73687f6cef81cb2be5943a6a91 Mon Sep 17 00:00:00 2001 From: Jonas Date: Thu, 19 Sep 2024 16:41:32 -0400 Subject: [PATCH 08/11] Update docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx Co-authored-by: Liza Mock --- .../transaction-vs-continuous-profiling.mdx | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx b/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx index d876f60d7a56c..79a1f85d19bac 100644 --- a/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx +++ b/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx @@ -9,13 +9,17 @@ We've released a new profiling mode called **continuous profiling**. Read on to ## Historical Context -Transaction based profiling was the first profiling mode supported at Sentry, it simply means that any code executed between Sentry.startTransaction and transaction.finish is subject to being profiled. In this mode, all profiles are attached to transactions (and are even sent as part of the same envelope). This has the benefit of automatically profiling parts of the application that are actually instrumented while requiring no extra effort. This approach however has drawback that continuous profiling aims to address, one of the most obvious ones being that profiles cannot exceed 30 second durations. +Transaction-based profiling was the first profiling mode supported by Sentry. It made it so that any code executed between `Sentry.startTransaction` and `transaction.finish` could be profiled. In this mode, all profiles were attached to transactions and sent as part of the same envelope. -In theory, transactions can be infinitely long as their duration does not impact payload size as start and end are represented by two timestamps. Profiles however are different, each stack sample that is collected by the profiler increases the payload size, which is why all Sentry SDKs had enforced a max profile duration of 30s. This limitation helps us safeguard from large payload that could otherwise harm your application performance. This unfortunately comes at the expense of limiting profiling capabilities as it means profiling is now no longer able to profile long running tasks like machine learning pipelines or build workflows. This feedback was the major driving force why we've introduced continuous profiling. +This had the benefit of automatically profiling parts of the application that were actually instrumented while requiring no extra effort. This approach had drawbacks that continuous profiling aims to address - one of the most obvious ones being that profiles couldn't exceed 30-second durations. -The cap on max profile duration is however not the only drawback of transaction based profiling, another limitation of it is that the profiling data you collect, will only ever be as good as the instrumentation you have. In other words, if there are parts of your application that you did not instrument, the chance of you finding out that they are slowing down your application are near zero. +In theory, transactions can be infinitely long since their duration doesn't impact payload size because start and end are represented by two timestamps. But profiles are different. Each stack sample that is collected by the profiler increases the payload size, which is why all Sentry SDKs had enforced a max profile duration of 30s. This limitation helps safeguard against large payloads that could harm your application performance. -To address these limitations, we have worked on a different profiling mode, one that does not impose constraints on profile durations and can surface parts of your application that might be slowing down your application even though you may not have instrumented them. +This unfortunately, comes at the expense of limiting profiling capabilities, making it so that profiling isn't able to profile long-running tasks such as machine learning pipelines or build workflows. This feedback was the driving force behind continuous profiling. + +The cap on max profile duration isn't the only drawback of transaction-based profiling. Another limitation is that the profiling data you collect will only ever be as good as the instrumentation you have. In other words, if there are parts of your application that you didn't instrument, the chance of you finding out that they're slowing down your application are near zero. + +To address these limitations, we created a different profiling mode, one that doesn't impose constraints on profile durations and can surface parts of your application that might be slowing down your application even if you haven't instrumented them. ## Continuous profiling mode From bc6ebfb021d53d04ca8df0bddec05f8bcaedc1a9 Mon Sep 17 00:00:00 2001 From: Jonas Date: Thu, 19 Sep 2024 16:41:40 -0400 Subject: [PATCH 09/11] Update docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx Co-authored-by: Liza Mock --- .../profiling/transaction-vs-continuous-profiling.mdx | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx b/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx index 79a1f85d19bac..d18b7372574aa 100644 --- a/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx +++ b/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx @@ -21,11 +21,11 @@ The cap on max profile duration isn't the only drawback of transaction-based pro To address these limitations, we created a different profiling mode, one that doesn't impose constraints on profile durations and can surface parts of your application that might be slowing down your application even if you haven't instrumented them. -## Continuous profiling mode +## Continuous Profiling Mode -In countinuous profiling mode, the profiler runs continuously (no pun intended) and regularly flushes what we call profile "profile chunks" to the server, this enables us to extend profile durations and continuously profile your application. +In continuous profiling mode, the profiler runs continuously (no pun intended) and regularly flushes what we call "profile chunks" to the server. This enables us to extend profile durations and continuously profile your application. -Continuous profiling mode is suitable for profiling long running workflows or processes that you want full visibility into, while the transaction based profiling is largely suitable for workflows where you want to limit profiling to only a subset of your application. +Continuous profiling mode is capable of profiling long-running workflows or processes that you want full visibility into, while transaction-based profiling is intended for workflows where you want to limit profiling to only a subset of your application. ## SDK differences From 0a5194c785207fc08cc874d19f55909e16e91dee Mon Sep 17 00:00:00 2001 From: Jonas Date: Thu, 19 Sep 2024 16:41:52 -0400 Subject: [PATCH 10/11] Update docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx Co-authored-by: Liza Mock --- .../profiling/transaction-vs-continuous-profiling.mdx | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx b/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx index d18b7372574aa..8d0d245e8c0c2 100644 --- a/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx +++ b/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx @@ -28,11 +28,11 @@ In continuous profiling mode, the profiler runs continuously (no pun intended) a Continuous profiling mode is capable of profiling long-running workflows or processes that you want full visibility into, while transaction-based profiling is intended for workflows where you want to limit profiling to only a subset of your application. -## SDK differences +## SDK Differences -Transaction based profiling was opaque from the SDK point of view with the SDK being in full control of when the profiler woulds start and stop based on the transactions it would generate. In continuous profiling mode, this is no longer true. Developers can now control when the profiler is started or stopped via new top level SDK methods. The exact method naming varies, but most SDKs that support continuous profiling now expose a top level Sentry.profiler that exposes a startProfiling and stopProfiling method (please see SDK docs for exact definitions). +Transaction-based profiling was opaque from the SDK side, with the SDK being in full control of when the profiler would start and stop based on the transactions it generated. In continuous profiling mode, this is no longer true. Developers can now control when the profiler is started or stopped via new top-level SDK methods. The exact method-naming varies, but most SDKs that support continuous profiling now expose a top level `Sentry.profiler` that exposes a `startProfiling` and `stopProfiling` method. (Please see the SDK docs for exact definitions.) -It is advisable that you call the startProfiling method right after the Sentry SDK is initialized so that you gain visibility at the earliest point in your application lifecycle. From then on, the profiler will keep collecting profiles and sending chunks to Sentry until stopProfiling is called. +We recommend that you call the `startProfiling` method right after the Sentry SDK is initialized so that you gain visibility at the earliest point in your application lifecycle. From then on, the profiler will keep collecting profiles and sending chunks to Sentry until `stopProfiling` is called. ## Enabling transaction or continuous profiling mode From 773ce17374db65e974bf29e1c66f1046ddb4a186 Mon Sep 17 00:00:00 2001 From: Jonas Date: Thu, 19 Sep 2024 16:41:59 -0400 Subject: [PATCH 11/11] Update docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx Co-authored-by: Liza Mock --- .../profiling/transaction-vs-continuous-profiling.mdx | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx b/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx index 8d0d245e8c0c2..3b8b4b743e4f0 100644 --- a/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx +++ b/docs/product/explore/profiling/transaction-vs-continuous-profiling.mdx @@ -36,11 +36,11 @@ We recommend that you call the `startProfiling` method right after the Sentry SD ## Enabling transaction or continuous profiling mode -Unfortunately, it is currently not possible to use both profiling modes at the same time, as they are mutually exlusive. Since the mode you intend on using depend on the SDK initialization arguments, it means that the profiling mode will have to be selected at the time the Sentry SDK is initialized. +Unfortunately, at this time it's not possible to use both profiling modes at the same time since they're mutually exclusive. Since the mode you intend to use is dependent on the SDK initialization arguments, profiling mode will have to be selected when the Sentry SDK is first initialized. -To enable continuous profiling mode, you should ensure that neither profileSampleRate or profilesSampler are set as the values to the Sentry.Init call. If either of those value are set, the SDK will default to transaction based profiling. When the SDK is configured for continuous profiling, the top level calls to start profiles will enable calls to the profiler. If the SDK is configured for transaction based profiling, then these calls will void and not trigger the profiler. +To enable continuous profiling, you have to make sure that neither `profileSampleRate` nor `profilesSampler` are set as the values of the `Sentry.Init` call. If either of those values are set, the SDK will default to transaction-based profiling. When the SDK is configured for continuous profiling, the top level calls to start profiles will enable calls to the profiler. If the SDK is configured for transaction-based profiling, these calls will void and not trigger the profiler. -Example of enabling continuous profiling in NodeJS +Here's an example of how to enable continuous profiling in NodeJS: ```javascript Sentry.Init({