rename tabs

Author: Dora Chan

__tests__/__snapshots__/documentation.js.snap

@@ -278,12 +278,12 @@ Array [
   "meta/ip-ranges/index.html",
   "meta/soc2/index.html",
   "meta/terms/index.html",
-  "performance/discover/index.html",
-  "performance/discover/query-builder/index.html",
-  "performance/distributed-tracing/index.html",
-  "performance/getting-started/index.html",
-  "performance/performance-homepage/index.html",
-  "performance/performance-metrics/index.html",
+  "performance-monitoring/discover-queries/index.html",
+  "performance-monitoring/discover-queries/query-builder/index.html",
+  "performance-monitoring/distributed-tracing/index.html",
+  "performance-monitoring/getting-started/index.html",
+  "performance-monitoring/performance-homepage/index.html",
+  "performance-monitoring/performance-metrics/index.html",
   "platforms/android/index.html",
   "platforms/android/migrate/index.html",
   "platforms/cocoa/dsym/index.html",

src/_data/documentation_categories.yml

@@ -9,8 +9,8 @@
 - title: Enriching Error Data
   slug: enriching-error-data
 
-- title: Performance
-  slug: performance
+- title: Performance Monitoring
+  slug: performance-monitoring
 
 - title: Workflow and Integrations
   slug: workflow

src/collections/_documentation/data-management/advanced-datascrubbing.md

@@ -164,7 +164,7 @@ Select known parts of the schema using the following:
 * `$logentry` matches the `logentry` attribute of an event.
 * `$thread` matches a single thread instance in `{"threads": {"values": [...]}}`
 * `$breadcrumb` matches a single breadcrumb in `{"breadcrumbs": {"values": [...]}}`
-* `$span` matches a [trace span]({% link _documentation/performance/distributed-tracing.md %}#traces-transactions-and-spans)
+* `$span` matches a [trace span]({% link _documentation/performance-monitoring/distributed-tracing.md %}#traces-transactions-and-spans)
 * `$sdk` matches the SDK context in `{"sdk": ...}`
 
 ### Escaping Special Characters

src/collections/_documentation/enriching-error-data/additional-data.md

@@ -28,7 +28,7 @@ Context includes additional diagnostic information attached to an event. By defa
 
 ## Predefined Data
 
-The most common types of predefined data (where applicable) are level, [release]({%- link _documentation/workflow/releases/index.md -%}), [environment]({%- link _documentation/enriching-error-data/environments.md -%}), logger, [fingerprint]({%- link _documentation/data-management/event-grouping/index.md -%}), user, request, device, OS, runtime, app, browser, gpu, monitor, and [traces]({%- link _documentation/performance/distributed-tracing.md -%}).
+The most common types of predefined data (where applicable) are level, [release]({%- link _documentation/workflow/releases/index.md -%}), [environment]({%- link _documentation/enriching-error-data/environments.md -%}), logger, [fingerprint]({%- link _documentation/data-management/event-grouping/index.md -%}), user, request, device, OS, runtime, app, browser, gpu, monitor, and [traces]({%- link _documentation/performance-monitoring/distributed-tracing.md -%}).
 
 To improve searchability, Sentry will turn the data or specific attributes on the data into tags. For example, `level` is available as a tag, and so is a user's email via the `user.email` tag. If Sentry is captures some predefined data but doesn't expose it as a tag, you can always set a [custom tag](#tags) for it.
 

src/collections/_documentation/enriching-error-data/error-tracing.md

@@ -144,6 +144,6 @@ After you configure the variable in your SDK, the variable surfaces as a tag in
 
 ### Searching Request IDs in Sentry
 
-If you also need several example cases to supplement a unique request ID, you can use Sentry's [Discover]({%- link _documentation/performance/discover/index.md -%}) functionality to search for all request ids you've seen on a specific URL.
+If you also need several example cases to supplement a unique request ID, you can use Sentry's [Discover]({%- link _documentation/performance-monitoring/discover-queries/index.md -%}) functionality to search for all request ids you've seen on a specific URL.
 
 [{% asset tracing/tracing_with_discover.png alt="Image of the request_id grouped with other tags." %}]({% asset tracing/tracing_with_discover.png @path %})

src/collections/_documentation/guides/enrich-data/index.md

@@ -65,7 +65,7 @@ For instance, the Discover query below displays all the errors (total of 143 eve
 
 ![Discover Query]({% asset guides/enrich-data/004.png @path %})
 
-For more information, see [Discover]({%- link _documentation/performance/discover/index.md -%}).
+For more information, see [Discover]({%- link _documentation/performance-monitoring/discover-queries/index.md -%}).
 
 ### Issue Ownership
 

src/collections/_documentation/performance-monitoring/configuration/javascript.md

@@ -0,0 +1,151 @@
+To get started with performance monitoring using Sentry's JavaScript SDK, first install the `@sentry/apm` package:
+
+```bash
+npm install --save @sentry/apm
+```
+
+Next, initialize the integration in your call to `Sentry.init`:
+
+```jsx
+import * as Sentry from '@sentry/browser';
+import { Integrations as ApmIntegrations } from '@sentry/apm';
+Sentry.init({
+  dsn: '"___PUBLIC_DSN___"',
+  release: 'my-project-name@' + process.env.npm_package_version,
+  integrations: [
+    new ApmIntegrations.Tracing(),
+  ],
+  tracesSampleRate: 0.25, // must be present and non-zero
+});
+```
+
+Performance data is transmitted using a new event type called "transactions", which you can learn about in [Distributing Tracing]({%- link _documentation/performance-monitoring/distributed-tracing.md %}#traces-transactions-and-spans). **To sample transactions, you must set the `tracesSampleRate` configuration to a nonzero value.** The example configuration above will transmit 25% of captured transactions.
+
+Learn more about sampling in [Using Your SDK to Filter Events]({%- link _documentation/error-reporting/configuration/filtering.md %}).
+
+### JavaScript
+
+To access our tracing features, you will need to install our Tracing package `@sentry/apm`:
+
+```bash
+$ npm install @sentry/browser
+$ npm install @sentry/apm
+```
+
+Alternatively, instead of npm packages, you can use our pre-built CDN bundle that combines both `@sentry/browser` and `@sentry/apm`:
+
+```html
+<script src="https://browser.sentry-cdn.com/{% sdk_version sentry.javascript.browser %}/bundle.apm.min.js" crossorigin="anonymous"></script>
+```
+
+#### Automatic Instrumentation
+
+For `@sentry/browser`, we provide an integration called `Tracing` that does
+automatic instrumentation creating `pageload` and `navigation` transactions
+containing spans for XHR/fetch requests and Performance API entries such as
+marks, measures and resource timings.
+
+The `Tracing` integration is specific to `@sentry/browser` and does not work
+with `@sentry/node`.
+
+The `Tracing` integration resides in the `@sentry/apm` package. You can add it to your `Sentry.init` call:
+
+```javascript
+import * as Sentry from '@sentry/browser';
+import { Integrations as ApmIntegrations } from '@sentry/apm';
+
+Sentry.init({
+  dsn: '___PUBLIC_DSN___',
+  integrations: [
+    new ApmIntegrations.Tracing(),
+  ],
+  tracesSampleRate: 0.25,
+});
+```
+
+*NOTE:* The `Tracing` integration is available then under `Sentry.Integrations.Tracing` when using the CDN bundle.
+
+To send traces, you will need to set the `tracesSampleRate` to a nonzero value. The configuration above will capture 25% of your transactions.
+
+You can pass many different options to the `Tracing` integration (as an object of the form `{optionName: value}`), but it comes with reasonable defaults out of the box.
+
+For all possible options see [TypeDocs](https://getsentry.github.io/sentry-javascript/interfaces/apm.tracingoptions.html)
+
+*tracingOrigins Option*
+
+The default value of `tracingOrigins` is `['localhost', /^\//]`. The JavaScript SDK will attach the `sentry-trace` header to all outgoing XHR/fetch requests whose destination contains a string in the list or matches a regex in the list. If your frontend is making requests to a different domain, you will need to add it there in order to propagate the `sentry-trace` header to the backend services, which is required to link transactions together as part of a single trace.
+
+*Example:*
+
+- A frontend application is served from `example.com`
+- A backend service is served from `api.example.com`
+- The frontend application makes API calls to the backend
+- Therefore, the option needs to be configured like this: `new ApmIntegrations.Tracing({tracingOrigins: ['api.example.com']})`
+- Now outgoing XHR/fetch requests to `api.example.com` will get the `sentry-trace` header attached
+
+*NOTE:* You need to make sure your web server CORS is configured to allow the `sentry-trace` header. The configuration might look like `"Access-Control-Allow-Headers: sentry-trace"`, but this depends a lot on your set up. If you do not whitelist the `sentry-trace` header, the request might be blocked.
+
+#### Manual Instrumentation
+
+To manually instrument certain regions of your code, you can create a transaction to capture them.
+This is valid for both JavaScript Browser and Node and works independent of the `Tracing` integration.
+
+```javascript
+const transaction = Sentry.startTransaction({name: 'test-transaction'});
+const span = transaction.startChild({op: 'functionX'}); // This function returns a Span
+// functionCallX
+span.finish(); // Remember that only finished spans will be sent with the transaction
+transaction.finish(); // Finishing the transaction will send it to Sentry
+```
+
+Here is a different example. If you want to create a transaction for a user interaction on you page, you need to do the following:
+
+```javascript
+// Let's say this function is invoked when a user clicks on the checkout button of your shop
+shopCheckout() {
+  // This will create a new Transaction for you
+  const transaction = Sentry.startTransaction('shopCheckout');
+
+  // Assume this function makes an xhr/fetch call
+  const result = validateShoppingCartOnServer(); 
+  
+  const span = transaction.startChild({
+    data: {
+      result
+    },
+    op: 'task',
+    description: `processing shopping cart result`,
+  });
+  processAndValidateShoppingCart(result);
+  span.finish();
+
+  transaction.finish();
+}
+```
+
+This example will send a transaction `shopCheckout` to Sentry, the transaction will contain a `task` span that measures how long `processAndValidateShoppingCart` took. Finally, the call to `transaction.finish()` will finish the transaction and send it to Sentry.
+
+#### Adding Additional Spans to the Transaction
+
+The next example contains the implementation of the hypothetical `processItem ` function called from the code snippet in the previous section. Our SDK can determine if there is currently an open transaction and add to it all newly created spans as child operations. Keep in mind that each individual span needs to be manually finished; otherwise, that span will not show up in the transaction.
+
+```javascript
+function processItem(item, transaction) {
+  const span = transaction.startChild({
+    op: "http",
+    description: "GET /"
+  })
+
+  return new Promise((resolve, reject) => {
+    http.get(`/items/${item.id}`, (response) => {
+      response.on('data', () => {});
+      response.on('end', () => {
+        span.setTag("http.status_code", response.statusCode);
+        span.setData("http.foobarsessionid", getFoobarSessionid(response));
+        span.finish();
+        resolve(response);
+      });
+    });
+  });
+}
+```

src/collections/_documentation/performance-monitoring/configuration/node.md

@@ -0,0 +1,85 @@
+### Node.js
+
+To access our tracing features, you will need to install our Tracing integration:
+
+```bash
+$ npm install @sentry/node
+$ npm install @sentry/apm
+```
+
+#### Sending Traces
+
+To send traces, set the `tracesSampleRate` to a nonzero value. The following configuration will capture 25% of all your transactions:
+
+```javascript
+const Sentry = require("@sentry/node");
+
+// This is required since it patches functions on the hub
+const Apm = require("@sentry/apm"); 
+
+Sentry.init({
+  dsn: "___PUBLIC_DSN___",
+  tracesSampleRate: 0.25
+});
+```
+
+#### Automatic Instrumentation
+
+It’s possible to add tracing to all popular frameworks; however, we provide pre-written handlers only for Express.
+
+```javascript
+const Sentry = require("@sentry/node");
+const Apm = require("@sentry/apm");
+const express = require("express");
+const app = express();
+
+Sentry.init({
+  dsn: "___PUBLIC_DSN___",
+  integrations: [
+      // enable HTTP calls tracing
+      new Sentry.Integrations.Http({ tracing: true }),
+      // enable Express.js middleware tracing
+      new Apm.Integrations.Express({ app })
+  ],
+  tracesSampleRate: 0.25
+});
+
+// RequestHandler creates a separate execution context using domains, so that every 
+// transaction/span/breadcrumb is attached to its own Hub instance
+app.use(Sentry.Handlers.requestHandler());
+// TracingHandler creates a trace for every incoming request
+app.use(Sentry.Handlers.tracingHandler());
+
+// the rest of your app
+
+app.use(Sentry.Handlers.errorHandler());
+app.listen(3000);
+```
+
+Spans are instrumented for the following operations within a transaction:
+
+- HTTP requests made with `request`
+- `get` calls using native `http` and `https` modules
+- Middleware (Express.js only)
+
+#### Manual Transactions
+
+To manually instrument a certain region of your code, you can create a transaction to capture it.
+
+The following example creates a transaction for a part of the code that contains an expensive operation (for example, `processItem`), and sends the result to Sentry:
+
+```javascript
+app.use(function processItems(req, res, next) {
+  const item = getFromQueue();
+  const transaction = Sentry.startTransaction({
+      op: "task",  
+      name: item.getTransaction()
+  })
+
+  // processItem may create more spans internally (see next examples)
+  processItem(item, transaction).then(() => {
+      transaction.finish();
+      next();
+  })
+});
+```

src/collections/_documentation/performance-monitoring/configuration/python.md

@@ -0,0 +1,93 @@
+To get started with performance monitoring using Sentry's Python SDK, first install the `@sentry/apm` package:
+
+```
+import sentry_sdk
+```
+
+Next, initialize the integration in your call to `Sentry.init`:
+
+```
+sentry_sdk.init(
+    "___PUBLIC_DSN___", 
+    traces_sample_rate = 0.25
+)
+```
+
+Performance data is transmitted using a new event type called "transactions", which you can learn about in [Distributing Tracing]({%- link _documentation/performance-monitoring/distributed-tracing.md %}#traces-transactions-and-spans). **To sample transactions, you must set the `tracesSampleRate` configuration to a nonzero value.** The example configuration above will transmit 25% of captured traces.
+
+Learn more about sampling in [Using Your SDK to Filter Events]({%- link _documentation/error-reporting/configuration/filtering.md %}).
+
+### Python
+
+To send traces, set the `traces_sample_rate` to a nonzero value. The following configuration will capture 25% of your transactions:
+
+```python
+import sentry_sdk
+
+sentry_sdk.init(
+    "___PUBLIC_DSN___", 
+    traces_sample_rate = 0.25
+)
+```
+
+#### Automatic Instrumentation
+
+Many integrations for popular frameworks automatically capture transactions. If you already have any of the following frameworks set up for Sentry error reporting, you will start to see traces immediately:
+
+- All WSGI-based web frameworks (Django, Flask, Pyramid, Falcon, Bottle)
+- Celery
+- AIOHTTP web apps
+- Redis Queue (RQ)
+
+Spans are instrumented for the following operations within a transaction:
+
+- Database queries that use SQLAlchemy or the Django ORM
+- HTTP requests made with `requests` or the `stdlib`
+- Spawned subprocesses
+- Redis operations
+
+If you want to enable all relevant transactions automatically, you can use this alternative configuration (currently in alpha):
+
+```python
+import sentry_sdk
+
+sentry_sdk.init(
+    "___PUBLIC_DSN___",
+    _experiments={"auto_enabling_integrations": True}
+)
+```
+
+#### Manual Instrumentation
+
+To manually instrument certain regions of your code, you can create a transaction to capture them.
+
+The following example creates a transaction for a scope that contains an expensive operation (for example, `process_item`), and sends the result to Sentry:
+
+```python
+import sentry_sdk
+
+while True:
+  item = get_from_queue()
+
+  with sentry_sdk.start_span(op="task", transaction=item.get_transaction()):
+      # process_item may create more spans internally (see next examples)
+      process_item(item)
+```
+
+#### Adding More Spans to the Transaction
+
+The next example contains the implementation of the hypothetical `process_item` function called from the code snippet in the previous section. Our SDK can determine if there is currently an open transaction and add all newly created spans as child operations to that transaction. Keep in mind that each individual span also needs to be manually finished; otherwise, spans will not show up in the transaction.
+
+You can choose the value of `op` and `description`.
+
+```python
+import sentry_sdk
+
+def process_item(item):
+
+  # omitted code...
+  with sentry_sdk.start_span(op="http", description="GET /") as span:
+      response = my_custom_http_library.request("GET", "/")
+      span.set_tag("http.status_code", response.status_code)
+      span.set_data("http.foobarsessionid", get_foobar_sessionid())
+```