docs(express): add v7 docs for express

Author: chargome

docs/platforms/javascript/guides/express/index__v7.x.mdx

@@ -0,0 +1,14 @@
+---
+title: Express
+description: "Learn about using Sentry with Express."
+sdk: sentry.javascript.node
+fallbackGuide: javascript.node
+categories:
+  - server
+---
+
+<PlatformContent includePath="getting-started-primer" />
+
+This guide explains how to set up Sentry in your Express application.
+
+<PlatformContent includePath="getting-started-node" />

docs/platforms/javascript/guides/express/img/express-data-filters.png renamed to platform-includes/getting-started-node/img/express-data-filters.png

@@ -0,0 +1,195 @@
+
+<OnboardingOptionButtons
+  options={["error-monitoring", "performance", "profiling"]}
+/>
+<PlatformContent includePath="getting-started-install" />
+
+Sentry should be initialized as early in your app as possible:
+
+```javascript {tabTitle:CommonJS} {filename: instrument.js} {"onboardingOptions": {"performance": "10-14", "profiling": "3, 15-18, 22"}}
+const express = require('express');
+const Sentry = require('@sentry/node');
+const { nodeProfilingIntegration } = require("@sentry/profiling-node");
+
+const app = express();
+
+// Sentry must be initialized as early as possible
+Sentry.init({
+  dsn: "___DSN___",
+
+  // Add Performance Monitoring by setting tracesSampleRate and adding integration
+  // Set tracesSampleRate to 1.0 to capture 100% of transactions
+  // We recommend adjusting this value in production
+  tracesSampleRate: 1.0,
+
+  // Set sampling rate for profiling
+  // This is relative to tracesSampleRate
+  profilesSampleRate: 1.0,
+  
+  integrations: [
+    expressIntegration({ app }),
+    nodeProfilingIntegration(),
+  ],
+  
+  // It is possible to specify the routes that should be traced by passing a router instance to the `router` option:
+  // expressIntegration({ router: someRouterInstance })
+});
+
+// The Sentry request handler middleware must be added before any other handlers
+app.use(Sentry.Handlers.requestHandler());
+// Performance Monitoring: Create spans and traces for every incoming request
+app.use(Sentry.Handlers.tracingHandler());
+
+// All controllers should live here
+app.get("/", function rootHandler(req, res) {
+  res.end("Hello world!");
+});
+
+// The Sentry error handler middleware must be registered before any other error middleware and after all controllers
+app.use(Sentry.Handlers.errorHandler());
+
+// Optional fallthrough error handler
+app.use(function onError(err, req, res, next) {
+  // The ID of error events captured by the Sentry error middleware is attached to `res.sentry`.
+  // You can use this ID for debugging, or to correlate requests with errors in Sentry.
+  res.statusCode = 500;
+  res.end(res.sentry + "\n");
+});
+
+app.listen(3000);
+```
+
+```javascript {tabTitle:ESM} {filename: instrument.mjs} {"onboardingOptions": {"performance": "10-14", "profiling": "3, 15-18, 22"}}
+import express from "express";
+import * as Sentry from "@sentry/node";
+import { nodeProfilingIntegration } from '@sentry/profiling-node';
+
+const app = express();
+
+// Sentry must be initialized as early as possible
+Sentry.init({
+  dsn: "___DSN___",
+
+  // Add Performance Monitoring by setting tracesSampleRate and adding integration
+  // Set tracesSampleRate to 1.0 to capture 100% of transactions
+  // We recommend adjusting this value in production
+  tracesSampleRate: 1.0,
+
+  // Set sampling rate for profiling
+  // This is relative to tracesSampleRate
+  profilesSampleRate: 1.0,
+  
+  integrations: [
+    expressIntegration({ app }),
+    nodeProfilingIntegration(),
+  ],
+  
+  // It is possible to specify the routes that should be traced by passing a router instance to the `router` option:
+  // expressIntegration({ router: someRouterInstance })
+});
+
+// The Sentry request handler middleware must be added before any other handlers
+app.use(Sentry.Handlers.requestHandler());
+// Performance Monitoring: Create spans and traces for every incoming request
+app.use(Sentry.Handlers.tracingHandler());
+
+// All controllers should live here
+app.get("/", function rootHandler(req, res) {
+  res.end("Hello world!");
+});
+
+// The Sentry error handler middleware must be registered before any other error middleware and after all controllers
+app.use(Sentry.Handlers.errorHandler());
+
+// Optional fallthrough error handler
+app.use(function onError(err, req, res, next) {
+  // The ID of error events captured by the Sentry error middleware is attached to `res.sentry`.
+  // You can use this ID for debugging, or to correlate requests with errors in Sentry.
+  res.statusCode = 500;
+  res.end(res.sentry + "\n");
+});
+
+app.listen(3000);
+```
+
+You can verify the Sentry integration by creating a route that will throw an error:
+
+```javascript
+app.get("/debug-sentry", function mainHandler(req, res) {
+  throw new Error("My first Sentry error!");
+});
+```
+
+`requestHandler` accepts some options that let you decide what data should be included in the event sent to Sentry.
+
+Possible options are:
+
+```javascript
+// keys to be extracted from req
+request?: boolean | string[]; // default: true = ['cookies', 'data', 'headers', 'method', 'query_string', 'url']
+
+// server name
+serverName?: boolean; // default: true
+
+// generate transaction name
+//   path == request.path (eg. "/foo")
+//   methodPath == request.method + request.path (eg. "GET|/foo")
+//   handler == function name (eg. "fooHandler")
+transaction?: boolean | 'path' | 'methodPath' | 'handler'; // default: true = 'methodPath'
+
+// keys to be extracted from req.user
+user?: boolean | string[]; // default: true = ['id', 'username', 'email']
+
+// client ip address
+ip?: boolean; // default: false
+
+// node version
+version?: boolean; // default: true
+
+// timeout for fatal route errors to be delivered
+flushTimeout?: number; // default: undefined
+```
+
+For example, if you want to skip the server name and add just user, you would use requestHandler like this:
+
+```javascript
+app.use(
+  Sentry.Handlers.requestHandler({
+    serverName: false,
+    user: ["email"],
+  })
+);
+```
+
+By default, `errorHandler` will capture only errors with a status code of `500` or higher. If you want to change it, provide it with the `shouldHandleError` callback, which accepts middleware errors as its argument and decides, whether an error should be sent or not, by returning an appropriate boolean value.
+
+```javascript
+app.use(
+  Sentry.Handlers.errorHandler({
+    shouldHandleError(error) {
+      // Capture all 404 and 500 errors
+      if (error.status === 404 || error.status === 500) {
+        return true;
+      }
+      return false;
+    },
+  })
+);
+```
+
+## Monitor Performance
+
+You can monitor the performance of your Express application by setting a `tracesSampleRate`, adding the `expressIntegration`, and registering the `tracingHandler` middleware.
+
+Spans are created for the following operations:
+
+- HTTP requests made with `request`
+- `get` calls using native `http` and `https` modules
+- Middleware (Express.js only)
+
+### Troubleshooting
+When capturing errors locally, ensure that your project's data filter for filtering localhost events is toggled off:
+
+![Issue alert](./img/express-data-filters.png)
+
+This ensures that errors produced by your browser (such as errors produced by HTTP methods) are properly captured.