diff --git a/develop-docs/application-architecture/feedback-architecture.mdx b/develop-docs/application-architecture/feedback-architecture.mdx
index bcbaf73ca0cce..19a4ba1c39408 100644
--- a/develop-docs/application-architecture/feedback-architecture.mdx
+++ b/develop-docs/application-architecture/feedback-architecture.mdx
@@ -16,12 +16,12 @@ When broken down, there are **4** ways to create feedback in our system, with
`FeedbackCreationSource(Enum)` in [create_feedback.py](https://github.com/getsentry/sentry/blob/2b642e149c79b251e1c2f4339fc73d656347d74e/src/sentry/feedback/usecases/create_feedback.py#L33-L33).
The 4 ways _clients_ can create feedback are:
-`NEW_FEEDBACK_ENVELOPE`: [The new format](/sdk/data-model/envelope-items/#user-feedback) created by the Replay team when adding
+`NEW_FEEDBACK_ENVELOPE`: [The new format](/sdk/foundations/data-model/envelope-items/#user-feedback) created by the Replay team when adding
the [User Feedback Widget](https://docs.sentry.io/product/user-feedback/#user-feedback-widget)
to the JavaScript SDK. It allows adding more information, for example tags,
release, url, etc.
-`USER_REPORT_ENVELOPE`: [The older format](/sdk/data-model/envelope-items/#user-report---deprecated) with name/email/comments, that requires
+`USER_REPORT_ENVELOPE`: [The older format](/sdk/foundations/data-model/envelope-items/#user-report---deprecated) with name/email/comments, that requires
`event_id` to link a Sentry error event.
`USER_REPORT_DJANGO_ENDPOINT`: [The deprecated Web API](https://docs.sentry.io/api/projects/submit-user-feedback/)
@@ -42,7 +42,7 @@ which
## Feedback events
-The preferred way of sending feedback from the SDK is in [feedback envelope](/sdk/data-model/envelope-items/#user-feedback).
+The preferred way of sending feedback from the SDK is in [feedback envelope](/sdk/foundations/data-model/envelope-items/#user-feedback).
The format is the same as error events, except the `type` header = `"feedback"`. While
user reports have an associated event, **new feedback _is_ an event**. This
offers 2 improvements:
@@ -93,7 +93,7 @@ In Relay v24.5.1, we migrated feedback to its own kafka topic + consumer,
### Attachments
-Attachments are another [item type](/sdk/data-model/envelopes/#attachment)
+Attachments are another [item type](/sdk/foundations/data-model/envelopes/#attachment)
in an envelope. We use attachments for the widget’s screenshot feature.
- SDK v8.0.0+, Relay v24.5.1+: Sends the feedback and attachment items in the same envelope.
@@ -185,7 +185,7 @@ graph TD
### Envelopes
-User reports are also sent to Relay in envelope format, item type [user_report](/sdk/data-model/envelope-items/#user-report---deprecated).
+User reports are also sent to Relay in envelope format, item type [user_report](/sdk/foundations/data-model/envelope-items/#user-report---deprecated).
The SDK function that sends these is `captureUserFeedback`.
diff --git a/develop-docs/backend/application-domains/transaction-clustering/index.mdx b/develop-docs/backend/application-domains/transaction-clustering/index.mdx
index 5b63ab8cca1f5..ea8cbae2a7ab4 100644
--- a/develop-docs/backend/application-domains/transaction-clustering/index.mdx
+++ b/develop-docs/backend/application-domains/transaction-clustering/index.mdx
@@ -13,7 +13,7 @@ In terms of technical implementation, it is similar to [Data Scrubbing](/backend
## The Problem
In our [Insights](https://docs.sentry.io/product/insights/overview/) product, transactions are grouped by their name
-(the [`event.transaction`](/sdk/data-model/event-payloads/#optional-attributes) field).
+(the [`event.transaction`](/sdk/foundations/data-model/event-payloads/#optional-attributes) field).
This works well as long as the cardinality of distinct transaction names that the SDK sends is low, for example
by using the [route of a web framework](https://docs.sentry.io/platforms/javascript/guides/react/configuration/integrations/react-router/) as the transaction name.
diff --git a/develop-docs/backend/issue-platform/index.mdx b/develop-docs/backend/issue-platform/index.mdx
index 35043bd2f9f29..4bc546a86af99 100644
--- a/develop-docs/backend/issue-platform/index.mdx
+++ b/develop-docs/backend/issue-platform/index.mdx
@@ -145,7 +145,7 @@ The most current version of this schema is documented here:
Schema
-The event schema should match the Sentry event schema. Any fields/interfaces defined here can be passed along with your event. It's best to fill in as many of these as makes sense for your issue type.
+The event schema should match the Sentry event schema. Any fields/interfaces defined here can be passed along with your event. It's best to fill in as many of these as makes sense for your issue type.
There's a minimum set of fields which should be included:
diff --git a/develop-docs/sdk/expected-features/data-handling.mdx b/develop-docs/sdk/expected-features/data-handling.mdx
index 07344f7b0e80d..00a83e11d8f91 100644
--- a/develop-docs/sdk/expected-features/data-handling.mdx
+++ b/develop-docs/sdk/expected-features/data-handling.mdx
@@ -152,5 +152,5 @@ Fields in the event payload that allow user-specified or dynamic values are rest
Additionally, size limits apply to all store requests for the total size of the request, event payload, and attachments. Sentry rejects all requests exceeding these limits. Please refer the following resources for the exact size limits:
-- Envelope Endpoint Size Limits
+- Envelope Endpoint Size Limits
- Store Endpoint Size Limits
diff --git a/develop-docs/sdk/expected-features/index.mdx b/develop-docs/sdk/expected-features/index.mdx
index 8d4877067d99e..dc901f2396e62 100644
--- a/develop-docs/sdk/expected-features/index.mdx
+++ b/develop-docs/sdk/expected-features/index.mdx
@@ -44,7 +44,7 @@ With deeper framework integration, the automatic recording of breadcrumbs is pos
* System Events: low battery, low storage space, airplane mode started, memory warnings, device orientation changed, etc.
* [Outgoing HTTP requests](#http-client-integrations)
-Check out the [complete breadcrumb documentation](/sdk/data-model/event-payloads/breadcrumbs/#breadcrumb-types) for more types.
+Check out the [complete breadcrumb documentation](/sdk/foundations/data-model/event-payloads/breadcrumbs/#breadcrumb-types) for more types.
## Event Sampling
@@ -128,7 +128,7 @@ An SDK may optionally track feature flag evaluations. Feature flags can be attac
When tracking feature flag evaluations on spans, we track the first 10 feature flags evaluated within the span's scope. Evaluations are span attributes and follow the existing span attribute schema.
-When tracking on error feature flag evaluations, we record the 100 most recent, unique feature flag evaluations. Evaluations are stored on the scope. When the scope forks a copy of the collected feature flag evaluations are given to the child scope. Mutations to the child's copy of the feature flags object should not be propagated to the parent. Flag evaluations within a scope are considered local to the scope and do not propagate. Evaluations should be submitted to Sentry following the schema specified in the Feature Flag Context protocol documentation.
+When tracking on error feature flag evaluations, we record the 100 most recent, unique feature flag evaluations. Evaluations are stored on the scope. When the scope forks a copy of the collected feature flag evaluations are given to the child scope. Mutations to the child's copy of the feature flags object should not be propagated to the parent. Flag evaluations within a scope are considered local to the scope and do not propagate. Evaluations should be submitted to Sentry following the schema specified in the Feature Flag Context protocol documentation.
If an SDK supports feature flags it must expose a function `add_feature_flag` which has similar behavior to the `set_tag` function. It must accept a key of type string and a value which is a union of string, boolean, integer, float, and structure.
@@ -146,7 +146,7 @@ Ability to get the ID of the last event sent. Event IDs are useful for correlati
## User Feedback
-For all SDKs, it is strongly recommended to send the `User Feedback` as an [envelope item](/sdk/data-model/envelope-items/#user-report---deprecated). Alternatively, the SDKs can
+For all SDKs, it is strongly recommended to send the `User Feedback` as an [envelope item](/sdk/foundations/data-model/envelope-items/#user-report---deprecated). Alternatively, the SDKs can
use the [User Feedback endpoint](https://docs.sentry.io/api/projects/submit-user-feedback/), which is not recommended.
### User Facing Platforms
@@ -194,7 +194,7 @@ Envelope item:
## Attachments
-Attachments are files stored alongside an event. To send an attachment, add it as an [envelope item](/sdk/data-model/envelope-items/#attachment)
+Attachments are files stored alongside an event. To send an attachment, add it as an [envelope item](/sdk/foundations/data-model/envelope-items/#attachment)
to the corresponding event.
We recommend implementing two types of attachments, one with a path and another with a byte array.
@@ -206,7 +206,7 @@ The overload that takes a `path` should consider:
* If reading the attachment fails, the SDK should not drop the whole envelope, but just the attachment's envelope item.
* If the SDK is in debug mode log (`debug=true`) out errors to make debugging easier.
-If the SDK supports [transactions](/sdk/data-model/envelope-items/#transaction), the attachments should offer a flag `addToTransactions`,
+If the SDK supports [transactions](/sdk/foundations/data-model/envelope-items/#transaction), the attachments should offer a flag `addToTransactions`,
that specifies if SDK adds the attachment to every transaction or not. The default should be `false`.
Use the implementations of [Java](https://github.com/getsentry/sentry-java/blob/main/sentry/src/main/java/io/sentry/Attachment.java),
@@ -222,7 +222,7 @@ useful because attachments could quickly eat up the users' disk space. Furthermo
## Screenshots
-When the user opts-in, if technically possible, take a screenshot of the application during a crash or error and include it as an [attachment](#attachments) to the [envelope](/sdk/data-model/envelopes/) with the event.
+When the user opts-in, if technically possible, take a screenshot of the application during a crash or error and include it as an [attachment](#attachments) to the [envelope](/sdk/foundations/data-model/envelopes/) with the event.
This feature only applies to SDKs with a user interface, such as Mobile and Desktop.
In some environments such as native iOS, taking a screenshot requires the UI thread and in the event of a crash, that might not be available. So inherently this feature will be a best effort solution.
@@ -369,7 +369,7 @@ If Performance Monitoring is both supported by the SDK and enabled in the client
- description: `$METHOD $url` (uppercase HTTP method), e.g. `GET https://sentry.io`
- HTTP requests must be enhanced with a [`sentry-trace` HTTP header](/sdk/telemetry/traces/#header-sentry-trace) to support [distributed tracing](https://docs.sentry.io/product/sentry-basics/tracing/distributed-tracing)
- HTTP requests must be enhanced with a [`baggage` HTTP header](/sdk/telemetry/traces/dynamic-sampling-context/#baggage-header) to support [dynamic sampling](/sdk/telemetry/traces/dynamic-sampling-context/)
-- span status must match HTTP response status code ([see Span status to HTTP status code mapping](/sdk/data-model/event-payloads/span/))
+- span status must match HTTP response status code ([see Span status to HTTP status code mapping](/sdk/foundations/data-model/event-payloads/span/))
- when network error occurs, span status must be set to `internal_error`
- span data must follow the [Span Data Conventions](/sdk/telemetry/traces/span-data-conventions/)
@@ -390,9 +390,9 @@ The HTTP Client integration should have 3 configuration options:
The HTTP Client integration should capture error events with the following properties:
-The Request interface, see the Spec for details.
+The Request interface, see the Spec for details.
-The Response context, see the Spec for details.
+The Response context, see the Spec for details.
```json
{
@@ -411,12 +411,12 @@ The Response context, see the Spec for details.
+The Exception Interface, see the Spec for details.
If the HTTP Client integration does not throw an exception for unsuccessful requests, you can create a synthetic exception following this Spec:
-- Set the Exception Mechanism with a proper `type` such as `SentryOkHttpInterceptor`.
-- Set the Stack Trace Interface with `snapshot=true`.
+- Set the Exception Mechanism with a proper `type` such as `SentryOkHttpInterceptor`.
+- Set the Stack Trace Interface with `snapshot=true`.
- `HTTP Client Error with status code: $code`.
When capturing error events, pass the original `Request` and `Response` objects from the HTTP Client as `hints`, so the users may filter out events in `beforeSend` with the full context.
diff --git a/develop-docs/sdk/foundations/data-model/envelope-items.mdx b/develop-docs/sdk/foundations/data-model/envelope-items.mdx
new file mode 100644
index 0000000000000..faa289cb9c7de
--- /dev/null
+++ b/develop-docs/sdk/foundations/data-model/envelope-items.mdx
@@ -0,0 +1,571 @@
+---
+title: Envelope Items
+sidebar_order: 3
+---
+
+Each Envelope consists of headers and a potentially empty list of Items, each
+with their own headers. Which Headers are required depends on the Items in an
+Envelope. This section describes all Item types and their respective required
+headers. It is worth noting that the list of Item types doesn't match the data
+categories used for [rate limiting](/sdk/foundations/transport/rate-limiting/#definitions) and
+client reports.
+
+The type of an Item is declared in the `type` header, as well as the payload
+size in `length`. See Serialization Format for a list of common Item headers.
+The headers described in this section are **in addition to the common headers**.
+
+### Event
+
+Item type `"event"`. This Item contains an error or default [event payload](/sdk/foundations/data-model/event-payloads/)
+encoded in JSON.
+
+**Constraints:**
+
+- This Item may occur at most once per Envelope.
+- This Item is mutually exclusive with `"transaction"` Items.
+
+**Envelope Headers:**
+
+`event_id`
+
+: **UUID String, required.** Corresponds to the `event_id` field of the event
+payload. Clients are required to generate an event identifier ahead of time
+and set it at least in the Envelope headers. If the identifier mismatches
+between the Envelope and payload, the Envelope header takes precedence.
+
+**Additional Item Headers:**
+
+_None_
+
+### Transaction
+
+Item type `"transaction"`. This Item contains a transaction payload encoded
+in JSON.
+
+**Constraints:**
+
+- This Item may occur at most once per Envelope.
+- This Item is mutually exclusive with `"event"` Items.
+
+**Envelope Headers:**
+
+`event_id`
+
+: **UUID String, required.** Corresponds to the `event_id` field of the
+transaction payload. Clients are required to generate an event identifier
+ahead of time and set it at least in the Envelope headers. If the identifier
+mismatches between the Envelope and payload, the Envelope header takes
+precedence.
+
+**Additional Item Headers:**
+
+_None_
+
+### Attachment
+
+Item type `"attachment"`. This Item contains a raw payload of an attachment
+file. It is always associated to an event or transaction.
+
+**Constraints:**
+
+- This Item may occur multiple times per Envelope.
+- For **minidump** and **apple crash report** attachments, the corresponding
+ `"event"` Item must be sent within the same Envelope.
+- Generic attachments can be ingested separately from their events. We recommend
+ sending them in the same Envelope, which allows for more efficient rate
+ limiting and filtering.
+- Generic attachments sent in separate Envelopes can be dropped independently of
+ an event. To ensure consistent handling, consider sending them in the same
+ request.
+- The Sentry server supports special attachments to ingest event payloads for
+ backwards compatibility. These are not part of the official public API and the
+ behavior should not be relied upon.
+
+**Envelope Headers:**
+
+`event_id`
+
+: **UUID String, required.** The identifier of the event or transaction.
+
+**Additional Item Headers:**
+
+`filename`
+
+: **String, required.** The name of the uploaded file without a path component.
+
+`attachment_type`
+
+: _String, optional._ The special type of this attachment. Possible values are:
+
+- **`event.attachment` (default)**: A standard attachment without special
+ meaning.
+- `event.minidump`: A minidump file that creates an error event and is
+ symbolicated. The file should start with the `MDMP` magic bytes.
+- `event.applecrashreport`: An Apple crash report file that creates an error
+ event and is symbolicated.
+- `unreal.context`: An XML file containing UE4 crash meta data. During event
+ ingestion, event contexts and extra fields are extracted from this file.
+- `unreal.logs`: A plain-text log file obtained from UE4 crashes. During
+ event ingestion, the last logs are extracted into event breadcrumbs.
+- `event.view_hierarchy`: An JSON file with a predefined structure, see [RFC #33](https://github.com/getsentry/rfcs/blob/main/text/0033-view-hierarchy.md).
+
+`content_type`
+
+: _String, optional._ The content type of the attachment payload. Any [MIME type](https://www.iana.org/assignments/media-types/media-types.xhtml) may be used; the default is `application/octet-stream`.
+
+### Trace Attachment
+
+
+Trace attachments are an experimental feature that is still under development.
+
+
+Item type `"attachment"` with content type `"application/vnd.sentry.trace-attachment"`. This item contains a raw payload of an attachment together with metadata. Contrary to V1 attachments, trace attachments are only optionally associated with other trace items (spans, logs, ...). Their main association is with the trace itself.
+
+**Envelope Headers:**
+
+- `trace` (optional): If the envelope containing the trace attachment has a [Dynamic Sampling Context](/sdk/telemetry/traces/dynamic-sampling-context), it will be subject to trace-based dynamic sampling rules, and potentially dropped.
+
+**Item Headers:**
+
+The trace attachment item header must contain the following properties:
+
+```json
+{
+ "type": "attachment",
+ "content_type": "application/vnd.sentry.trace-attachment",
+ "length": 212341234,
+ "meta_length": 123
+}
+```
+
+- `meta_length` is the size of the metadata portion of the payload in bytes (see item description below).
+
+
+**Item Payload:**
+
+The trace attachment item payload consists of a JSON object containing metadata followed by the attachment body. For example, for a plain text attachment with the body "helloworld", the item payload would look like this:
+
+```json
+{ // Attachment Metadata
+ "trace_id": "12312012123120121231201212312012",
+ "attachment_id": "019a72d07ffe77208c013ac888b38d9e",
+ "timestamp": 1760520026.781239,
+ "filename": "myfile.txt",
+ "content_type": "text/plain",
+ "attributes": {
+ // Arbitrary key value pairs that will end up in EAP.
+ "foo": {"type": "string", "value": "bar"}
+ }
+}helloworld
+```
+
+| Property | Type | Required | Description |
+|----------|------|----------|-------------|
+| `trace_id` | string | Yes | The trace ID. Determines which `trace` the attachment belongs to. 32-character hexadecimal string. |
+| `attachment_id` | string | Yes | 32-character hexadecimal string (a valid [Version 7](https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_7_(timestamp_and_random)) or Version 4 UUID without dashes) |
+| `timestamp` | float | Yes | a UNIX timestamp corresponding to the attachment's occurrence. It may be the same as the start or end timestamp of the owner span. |
+| `filename` | string | No | The file name of the attachment. |
+| `content_type` | string | Yes | the content type of the attachment body (not to be confused with the content type of the envelope item, which is always `application/vnd.sentry.trace-attachment`). |
+| `attributes` | object | No | arbitrary attributes that will be queryable on the attachment trace item, similar to spans, logs, and trace metrics. |
+
+
+### Session
+
+Item type `"session"` contains a single session initialization or update to an
+existing session for Release Health.
+
+See the sessions documentation for the payload
+details.
+
+**Constraints:**
+
+- This Item may occur multiple times per Envelope.
+- Ingestion may limit the maximum number of Items per Envelope, see _Ingestion_.
+
+**Additional Item Headers:**
+
+_None_
+
+### Sessions
+
+Item type `"sessions"` contains buckets of pre-aggregated session counts.
+
+See the sessions documentation for the payload
+details.
+
+**Constraints:**
+
+- This Item may occur multiple times per Envelope.
+- Ingestion may limit the maximum number of Items per Envelope, see _Ingestion_.
+
+**Additional Item Headers:**
+
+_None_
+
+### User Feedback
+
+Item type `"feedback"` contains an event with a feedback context in the payload encoded in JSON.
+
+Example payload:
+
+```json
+{
+ "event_id": "9ec79c33ec9942ab8353589fcb2e04dc",
+ "timestamp": "2011-05-02T17:41:36Z",
+ "platform": "javascript",
+ "level": "error",
+ "contexts": {
+ "feedback": {
+ "contact_email": "john@example.com",
+ "name": "John Smith",
+ "message": "I love session replay!",
+ "url": "https://sentry.io/replays/",
+ "associated_event_id": "32fd1995636d446385016e2747623e11",
+ "replay_id": "82840977e85b4ed3bc27f7b5b25cec15"
+ }
+ }
+}
+```
+
+**Payload Attributes**
+
+We only document attributes for the `contexts.feedback` object, which is **required**
+for this item type. For other attributes, see [Event Payloads](/sdk/foundations/data-model/event-payloads/).
+
+`message`
+
+: **String, required.** Comments of the user, describing what happened and/or sharing
+feedback. The max length is **4096 characters**.
+
+`contact_email`
+
+: _String, optional._ The email of the user who submitted the feedback. If excluded, Sentry attempts to fill this in with user context. Anonymous feedbacks (no name or email) are still accepted.
+
+`name`
+
+: _String, optional._ The name of the user who submitted the feedback. If excluded, Sentry attempts to fill this in with user context. Anonymous feedbacks (no name or email) are still accepted.
+
+`url`
+
+: _String, optional._ The URL of the webpage the user was on when submitting feedback.
+This may be used to search for or set alerts on feedback.
+
+`associated_event_id`
+
+: _UUID String, optional._ The identifier of an error event in the same project.
+Use this to explicitly link a related error in the feedback UI.
+
+`replay_id`
+
+: _UUID String, optional._ The identifier of a related Session Replay in the same
+project. Sentry uses this ID to render a Replay clip in the feedback UI.
+
+**Attaching Files:**
+
+You can attach files of any type to a feedback (screenshots, logs, documents, etc.) by sending them as
+[attachment items](/sdk/foundations/data-model/envelope-items/#attachment), with `event_id`
+corresponding to the feedback item. We recommend sending the attachment items in the same
+Envelope as the feedback item.
+
+**Constraints:**
+
+- This Item may occur at most once per Envelope.
+- This Item is mutually exclusive with `"transaction"` items.
+
+**Required Envelope Headers:**
+
+`event_id`
+
+: **UUID String, required.** Corresponds to the `event_id` field of the event
+payload. **It is not equal to the `associated_event_id`** field in the feedback
+context. Clients are required to generate an event identifier ahead of time
+and set it at least in the Envelope headers. If the identifier mismatches
+between the Envelope and payload, the Envelope header takes precedence.
+
+### User Report - Deprecated
+
+Item type `"user_report"`. This is an older, deprecated way of submitting user feedback. It continues to work so older SDKs won't break. New implementations should follow the `feedback` item type described above.
+
+This item works by associating user information and comments with an event. If both the item and its associated event are accepted, we convert it to a user feedback.
+
+The item contains a JSON payload like this:
+
+```json
+{"event_id":"9ec79c33ec9942ab8353589fcb2e04dc","email":"john@example.com","name":"John Me","comments":"It broke."}\n
+```
+
+**Payload Attributes**
+
+`event_id`
+
+: **UUID String, required.** The identifier of the associated event, ideally
+an error.
+
+`email`
+
+: _String, recommended._ The email of the user.
+
+`name`
+
+: _String, recommended._ The name of the user.
+
+`comments`
+
+: _String, recommended._ Comments of the user about what happened. The max length is **4096 characters**.
+
+**Constraints:**
+
+- This Item may occur once per Envelope.
+- User Reports can be ingested separately from their events. However, we recommend
+ sending them in the same Envelope.
+- You may not associate multiple User Reports to the same event.
+- The event can not be more than 30 minutes old.
+- If the event does not exist in the same project or was never ingested, the report
+ is discarded and never converted to feedback.
+
+**Envelope Headers:**
+
+`event_id`
+
+: **UUID String, required.** Corresponds to the `event_id` field of the payload.
+If the identifier mismatches between the Envelope and payload, the Envelope
+header takes precedence.
+
+**Additional Item Headers:**
+
+_None_
+
+### Client Report
+
+Item type `"client_report"` contains a client report payload encoded in JSON.
+
+See the client reports documentation for the payload
+details.
+
+**Constraints:**
+
+- This Item may occur multiple times per Envelope, but please avoid sending more client reports than necessary.
+- This Item can either be included in an Envelope with other Items, or it may be sent by itself.
+
+**Envelope Headers:**
+
+_None_
+
+**Additional Item Headers:**
+
+_None_
+
+### Replay Event
+
+Item type `"replay_event"` contains a replay payload encoded in JSON.
+
+See the replays documentation for the payload
+details.
+
+**Constraints:**
+
+- This Item may occur at most once per Envelope.
+- This Item must be sent with a Replay Recording Item.
+
+**Envelope Headers:**
+
+_None_
+
+**Additional Item Headers:**
+
+_None_
+
+### Replay Recording
+
+Item type `"replay_recording"` contains a replay recording payload encoded in JSON _or_ a gzipped JSON.
+
+See the replays documentation for the payload
+details.
+
+**Constraints:**
+
+- This Item may occur at most once per Envelope.
+- This Item must be sent with a Replay Event Item.
+
+**Envelope Headers:**
+
+_None_
+
+**Additional Item Headers:**
+
+`length`
+
+: **integer, required.** The size of the Replay recording payload
+
+### Profile
+
+Item type `"profile"`. This Item contains a profile payload encoded
+in JSON.
+
+**Constraints:**
+
+- This Item may occur at most once per Envelope.
+- This Item needs to be in the same Envelope as the associated transaction.
+
+**Envelope Headers:**
+
+_None_
+
+**Additional Item Headers:**
+
+_None_
+
+### Profile Chunk
+
+Item type `"profile_chunk"`. This Item contains a profile_chunk (profile sample format V2) payload encoded
+in JSON.
+
+**Constraints:**
+
+_None_
+
+**Envelope Headers:**
+
+_None_
+
+**Additional Item Headers:**
+
+`platform`
+
+: **String, required.** The platform of the profiled application. This item header is used for rate limiting and categorization. It must match the `platform` in the payload. the Examples: `"javascript"`, `"node"`, `"python"`, `"cocoa"`, etc.
+
+### Check-Ins
+
+Item type `"check_in"` contains a check-in payload encoded as JSON.
+
+See the Check-Ins documentation for the payload
+details.
+
+**Constraints:**
+
+- This Item may occur at most once per Envelope.
+- This Item can either be included in an Envelope with other Items, or it may be sent by itself.
+
+**Envelope Headers:**
+
+_None_
+
+**Additional Item Headers:**
+
+_None_
+
+### Log
+
+Item type `"log"` contains an array of log payloads encoded as JSON. This allows for multiple log payloads to be sent in a single envelope item.
+
+Only a single log container is allowed per envelope. The `item_count` field in the envelope item header must match the amount of logs sent, it's not optional. A `content_type` field in the envelope item header must be set to `application/vnd.sentry.items.log+json`.
+
+It's okay to mix logs from different traces into the same log envelope item, but if you do, you MUST not attach a DSC (dynamic sampling context) to the envelope header.
+
+See the Logs documentation for the payload
+details. For an example `log` envelope, see [Appendix A of the Logs documentation](/sdk/telemetry/logs#appendix-a-log-envelope-item-payload).
+
+Example:
+
+```json
+{
+ "type": "log",
+ "item_count": 5,
+ "content_type": "application/vnd.sentry.items.log+json"
+}
+{
+ "items": [{..log..}, {..log..}, {..log..}, {..log..}, {..log..}]
+}
+```
+
+**Constraints:**
+
+_None_
+
+**Envelope Headers:**
+
+_None_
+
+**Additional Item Headers:**
+
+`item_count`
+
+: **integer, required.** The number of log entries in the envelope.
+
+`content_type`
+
+: **string, required.** The content type of the log entries. Must be `application/vnd.sentry.items.log+json`.
+
+### Otel Logs
+
+Item type `"otel_log"` contains an OpenTelemetry Logs payload encoded as JSON. Multiple Otel log envelope items can be sent in a single envelope.
+
+See the Logs documentation for the payload
+details.
+
+**Constraints:**
+
+_None_
+
+**Envelope Headers:**
+
+_None_
+
+**Additional Item Headers:**
+
+_None_
+
+### Spans
+
+For Version 2 of the spans protocol, see Span Protocol.
+
+### Trace Metric
+
+Item type `"trace_metric"` contains an array of metric payloads encoded as JSON. This allows for multiple metric payloads to be sent in a single envelope item.
+
+Only a single trace_metric container is allowed per envelope. The `item_count` field in the envelope item header must match the amount of metrics sent. A `content_type` field in the envelope item header must be set to `application/vnd.sentry.items.trace-metric+json`. Both the `item_count` and `content_type` fields are required.
+
+It's okay to mix metrics from different traces into the same `trace_metric` envelope item, but if you do, you MUST NOT attach a DSC (dynamic sampling context) to the envelope header.
+
+See the Metrics documentation for the payload
+details. For an example `trace_metric` envelope, see [Appendix A of the Metrics documentation](/sdk/telemetry/metrics#appendix-a-example-trace_metric-envelope).
+
+Example:
+
+```json
+{
+ "type": "trace_metric",
+ "item_count": 5,
+ "content_type": "application/vnd.sentry.items.trace-metric+json"
+}
+{
+ "items": [{..metric..}, {..metric..}, {..metric..}, {..metric..}, {..metric..}]
+}
+```
+
+**Constraints:**
+
+_None_
+
+**Envelope Headers:**
+
+_None_
+
+**Additional Item Headers:**
+
+`item_count`
+
+: **integer, required.** The number of metric entries in the envelope.
+
+`content_type`
+
+: **string, required.** The content type of the metric entries. Must be `application/vnd.sentry.items.trace-metric+json`.
+
+### Reserved Types
+
+Reserved types may not be written by any implementation. They are reserved for
+future or internal use. This is the exhaustive list of reserved Item types:
+
+- `security`
+- `unreal_report`
+- `form_data`
diff --git a/develop-docs/sdk/foundations/data-model/envelopes.mdx b/develop-docs/sdk/foundations/data-model/envelopes.mdx
new file mode 100644
index 0000000000000..84c959873f963
--- /dev/null
+++ b/develop-docs/sdk/foundations/data-model/envelopes.mdx
@@ -0,0 +1,358 @@
+---
+title: Envelopes
+sidebar_order: 2
+---
+
+This document defines the Envelope and Item formats used by Sentry for data
+ingestion, forwarding, and offline storage. The target audience of this document
+is Sentry SDK developers and maintainers of the ingestion pipeline.
+
+
+
+Envelopes require Relay, which has been introduced in **Sentry v20.6.0**.
+Earlier versions of Sentry do not support Envelopes and respond with HTTP error
+_404 Not Found_ to envelope uploads. Likewise, Relay requires support for
+Envelopes on the upstream and cannot be used with older versions of Sentry.
+
+
+
+*Envelopes* are a data format similar to HTTP form data, comprising common
+*Headers* and a set of *Items* with their own headers and payloads. Envelopes
+are optimized for fast parsing and human readability. They support a combination
+of multiple Items in a single payload, such as:
+
+- Submit events with large binary attachments.
+- Enable communication between hops, for instance, between different SDKs
+ (Native and Mobile, ReactNative and Android) and between Relays.
+- Allow batching of certain Items into a single submission.
+- Offline storage for deferred sending after connection issues.
+
+Sentry specifies a dedicated endpoint at for ingesting Envelopes:
+
+```
+POST /api//envelope/
+```
+
+## Terminology
+
+- *required*: The implementation may emit an error if this field is missing.
+- *recommended*: This field should be emitted when writing, but can be missing
+ during a read.
+- *optional*: Can be omitted freely during writing and can be missing during a
+ read.
+
+## Serialization Format
+
+This section defines the Envelope data format and serialization. For details on
+data integrity and a list of valid Item types refer to [Envelope Items](/sdk/foundations/data-model/envelope-items/).
+
+### Prerequisites
+
+These definitions apply to all parts of the Envelope data format:
+
+1. Newlines are defined as UNIX newlines, represented by `\n` and ASCII code 10.
+ If newlines are preceded with `\r`, this character is considered part of the
+ previous line or payload and may emit an error.
+2. UUIDs are declared as either 32 character hexadecimal strings without dashes
+ (`"12c2d058d58442709aa2eca08bf20986"`), or 36 character strings with dashes
+ (`"12c2d058-d584-4270-9aa2-eca08bf20986"`). It is recommended to omit dashes
+ and use UUID v4 in all cases.
+3. Envelopes do not offer a mechanism for compression. However, an entire
+ Envelope may be compressed or decompressed in an implementation defined way
+ by any component handling Envelopes. For example, [Ingestion](#ingestion)
+ allows compression via content encoding.
+
+### Headers
+
+Envelopes contain Headers in several places. Headers are JSON-encoded objects
+(key-value mappings) that follow these rules:
+
+- Always encoded in UTF-8
+- Must be valid JSON
+- Must be declared in a single line; no newlines
+- Always followed by a newline (`\n`) or the end of the file
+- Must not be padded by leading or trailing whitespace
+- Should be serialized in their most compact form without additional white
+ space. Whitespace within the JSON headers is permitted, though discouraged.
+- Unknown attributes are allowed and should be retained by all implementations;
+ however, attributes not covered in this spec must not be actively emitted by
+ any implementation.
+- All known headers and their data types can be validated by an implementation;
+ if validation fails, the Envelope may be rejected as malformed.
+- Empty headers `{}` are technically valid
+
+Header-only Example:
+
+```json
+{"event_id":"12c2d058d58442709aa2eca08bf20986"}
+```
+
+### Envelopes
+
+The full grammar for an Envelope is:
+
+```
+Envelope = Headers { "\n" Item } [ "\n" ] ;
+Item = Headers "\n" Payload ;
+Payload = { * } ;
+```
+
+- **Headers** are a single line containing a JSON object, as defined in the
+ [Headers](#headers) section. Attributes defined in the Envelope header scope
+ the contents of the Envelope and can be thought of as applying to all Items.
+- Based on the contents of the Envelope, certain header attributes may be
+ required. See [Envelope Items](/sdk/foundations/data-model/envelope-items/) for a specification of required
+ attributes.
+- **Items** comprise their own headers and a payload. There can be
+ an arbitrary number of **Items** in an Envelope separated by a newline. An
+ implementation should consume Items until the file ends.
+- Envelopes should be terminated with a trailing newline. This newline is
+ optional. After the final newline, no whitespace is allowed.
+- Envelopes may be empty, terminating immediately after the headers.
+- The end of file (EOF) does not implicitly terminate an Envelope if more data
+ is expected, such as a Payload.
+
+### Envelope Headers
+
+Envelopes can have a number of headers which are valid in all situations:
+
+`dsn`
+
+: *String, recommended.* An envelope can be self authenticated. This means that
+ the envelope has all the information necessary to be sent to sentry. In this
+ case the full DSN must be stored in this key.
+
+`sdk`
+
+: *Object, recommended.* This can carry the same payload as the [`sdk` interface](/sdk/foundations/data-model/event-payloads/sdk/)
+ in the event payload but can be carried for all events. This means that SDK
+ information can be carried for minidumps, session data and other submissions.
+
+`sent_at`
+
+: *String, recommended.* The timestamp when the event was sent from the SDK as string in
+ [RFC 3339](https://tools.ietf.org/html/rfc3339) format. Used for clock drift
+ correction of the event timestamp. The time zone must be UTC.
+
+
+
+It is recommend to *always* send the `sent_at` envelope header. Do not try to determine
+whether it should be sent or not, as that determination can be made on the receiving side.
+
+The timestamp should be generated as close as possible to the transmission of the event,
+so that the delay between sending the envelope and receiving it on the server-side
+is minimized. This is usually accomplished in serialization of the envelope header.
+
+However, care must be taken that the header is only applied *once*. If more than one `sent_at`
+header is written, Sentry will reject the entire envelope. For example, SDKs that implement
+caching features should avoid writing the `sent_at` header when caching to disk.
+Only write it when actually sending the event to Sentry.
+
+The timestamp can be generated by any of the following (for example):
+
+JavaScript
+
+: `new Date().toISOString()`
+
+Python
+
+: `datetime.now(timezone.utc).isoformat()`
+ *Don't use `datetime.utcnow()`, as it will omit the time zone.*
+
+.NET
+
+: `DateTime.UtcNow.ToString("o", CultureInfo.InvariantCulture)`
+ or
+ `DateTimeOffset.UtcNow.ToString("o", CultureInfo.InvariantCulture)`
+
+Java
+
+: `Instant.now().toString()`
+
+*Also note that the `sent_at` header replaces the `sentry_timestamp` key previously set in authorization headers,
+which has now been fully deprecated. You should only send `sent_at`, and not `sentry_timestamp`.*
+
+
+
+### Items
+
+Items supply the data of an Envelope. Without Items, an Envelope is considered
+*empty* and can safely be discarded.
+
+There are two generic headers for every Item:
+
+`type`
+
+: **String, required.** Specifies the type of this Item and its contents. Based
+ on the Item type, more headers may be required. See [Envelope Items](/sdk/foundations/data-model/envelope-items/) for a list
+ of all Item types.
+
+`length`
+
+: *int, recommended.* The length of the payload in bytes. If no `length` is
+ specified, the payload implicitly goes to the next newline. For payloads
+ containing newline characters, the `length` must be specified.
+
+
+By default, always declare the payload length to enable faster parsing of an
+Envelope.
+
+If the Envelope contains a large number of very small Items, omitting the length
+can be beneficial for compression. This is the case for sessions.
+
+The implementor should assess this on a per-case basis and explicitly argue
+about the decision.
+
+
+Notes for implementors:
+
+- Envelope header is **required**, but it can be empty.
+- Implementations **must gracefully skip and retain** Items of unknown type,
+ along with their payload.
+- Unknown attributes must be forwarded to the upstream.
+- Length-prefixed payloads must terminate with `\n` or EOF. The newline is not
+ considered part of the payload. Any other character, including whitespace,
+ means the Envelope is malformed.
+- If `length` cannot be consumed, that is, the Envelope is EOF before the number
+ of bytes has been consumed, then the Envelope is malformed.
+- If an Item with implicit length is terminated by `\r\n`, then `\r` is
+ considered an arbitrary character not part of the newline, and thus part of
+ the payload.
+
+### Full Examples
+
+These examples contain full Envelope payloads. Newlines are explicitly marked
+with `\n`, unprintable characters are escaped with `\x<><>`. all other
+characters are literal.
+
+**Envelope with 2 Items:**
+
+Note that the attachment contains a Windows newline at the end of its
+payload which is included in `length`:
+
+```
+{"event_id":"9ec79c33ec9942ab8353589fcb2e04dc","dsn":"https://e12d836b15bb49d7bbf99e64295d995b:@sentry.io/42"}\n
+{"type":"attachment","length":10,"content_type":"text/plain","filename":"hello.txt"}\n
+\xef\xbb\xbfHello\r\n\n
+{"type":"event","length":41,"content_type":"application/json","filename":"application.log"}\n
+{"message":"hello world","level":"error"}\n
+```
+
+**Envelope with 2 Items, last newline omitted:**
+
+Note that the attachment contains a Windows newline at the end of its
+payload which is included in `length`:
+
+```
+{"event_id":"9ec79c33ec9942ab8353589fcb2e04dc","dsn":"https://e12d836b15bb49d7bbf99e64295d995b:@sentry.io/42"}\n
+{"type":"attachment","length":10,"content_type":"text/plain","filename":"hello.txt"}\n
+\xef\xbb\xbfHello\r\n\n
+{"type":"event","length":41,"content_type":"application/json","filename":"application.log"}\n
+{"message":"hello world","level":"error"}
+```
+
+**Envelope with 2 empty attachments:**
+
+```
+{"event_id":"9ec79c33ec9942ab8353589fcb2e04dc"}\n
+{"type":"attachment","length":0}\n
+\n
+{"type":"attachment","length":0}\n
+\n
+```
+
+**Envelope with 2 empty attachments, last newline omitted:**
+
+```
+{"event_id":"9ec79c33ec9942ab8353589fcb2e04dc"}\n
+{"type":"attachment","length":0}\n
+\n
+{"type":"attachment","length":0}\n
+```
+
+**Item with implicit length, terminated by newline:**
+
+```
+{"event_id":"9ec79c33ec9942ab8353589fcb2e04dc"}\n
+{"type":"attachment"}\n
+helloworld\n
+```
+
+**Item with implicit length, last newline omitted, terminated by EOF:**
+
+```
+{"event_id":"9ec79c33ec9942ab8353589fcb2e04dc"}\n
+{"type":"attachment"}\n
+helloworld
+```
+
+**Envelope without headers, implicit length, last newline omitted, terminated by
+EOF:**
+
+```
+{}\n
+{"type":"session"}\n
+{"started": "2020-02-07T14:16:00Z","attrs":{"release":"sentry-test@1.0.0"}}
+```
+
+## Data Model
+
+This section has been moved to [Envelope Items](/sdk/foundations/data-model/envelope-items/).
+## Ingestion
+
+This section describes how to ingest Envelopes into Relay or Sentry. The main
+ingestion endpoint for Envelopes is:
+
+```
+POST /api//envelope/
+```
+
+### HTTP Headers
+
+Envelope requests may contain all headers as regular store requests. The only
+accepted `content-type` is `application/x-sentry-envelope`, which is implied if
+it is missing. To minimize the necessity for `CORS` preflights it's
+acceptable to send `text/plain`, `multipart/form-data` and
+`application/x-www-form-urlencoded` as well. In either of those cases the
+behavior however is the same as using `application/x-sentry-envelope`.
+
+### Authentication
+
+In addition to regular HTTP header- and querystring authentication, the Envelope
+endpoint allows to authenticate via an Envelope header. To choose this
+authentication method, set the `"dsn"` Envelope header to the full DSN string.
+
+If multiple forms of authentication are given, the endpoint validates that the
+information matches and otherwise rejects the request. If both are missing, the
+Envelope is rejected with status code `403 Forbidden`.
+
+
+
+Envelope header authentication requires **Relay v21.6.0**.
+Earlier versions of Relay do not support Envelope header authentication and respond with HTTP error
+_401 Unauthorized ("missing authorization information")_ to envelope uploads.
+
+SDKs should not rely on Envelope header authentication to retain backward compatibility with older versions of Sentry on-premise unless absolutely required. Instead, stick to HTTP headers or query parameters wherever possible.
+
+
+
+### Size Limits
+
+Event ingestion imposes limits on the size and number of Items in Envelopes.
+These limits are subject to future change and defined currently as (see [Relay config source](https://github.com/getsentry/relay/blob/master/relay-config/src/config.rs)):
+
+- *200 MiB* for an envelope after decompression including all envelope items.
+- *1 MiB* for event (errors and transactions), span, log, and metric (statsd, buckets, meta) envelope items.
+- *2 KiB* for each metric within an envelope. Relay discards the entire envelope if the one of the metrics exceeds 2 KiB.
+- *100 KiB* for monitor check-in items
+- *4 KiB* for client report items
+- *50 MiB* for profile items
+- *10 MiB* for compressed replay items
+- *100 MiB* for replay items after decompression
+- *100 sessions* per envelope
+- *100 pre-aggregated session buckets* per each `"sessions"` item
+
+## External References
+
+- [Multi Part Form Data](https://tools.ietf.org/html/rfc7578)
+- [Chunked Transfer Encoding](https://en.wikipedia.org/wiki/Chunked_transfer_encoding)
diff --git a/develop-docs/sdk/data-model/event-payloads/breadcrumbs.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/breadcrumbs.mdx
similarity index 100%
rename from develop-docs/sdk/data-model/event-payloads/breadcrumbs.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/breadcrumbs.mdx
diff --git a/develop-docs/sdk/data-model/event-payloads/contexts.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/contexts.mdx
similarity index 99%
rename from develop-docs/sdk/data-model/event-payloads/contexts.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/contexts.mdx
index 8f42b582a90bf..9a740a4083d34 100644
--- a/develop-docs/sdk/data-model/event-payloads/contexts.mdx
+++ b/develop-docs/sdk/foundations/data-model/event-payloads/contexts.mdx
@@ -206,7 +206,7 @@ confusion about which OS context represents what. So here's some examples:
the SDK (if at all).
Additionally, the Sentry server will attempt to parse the `User-Agent` header
- from the event's [Request Interface](/sdk/data-model/event-payloads/request/) and create a _secondary_ OS
+ from the event's [Request Interface](/sdk/foundations/data-model/event-payloads/request/) and create a _secondary_ OS
context under the non-default key `"client_os"`.
- In events reported from a JS web frontend, the SDK typically reports no OS
@@ -604,7 +604,7 @@ The `type` and default key is `"cloud_resource"`.
**Example Cloud Resource Context**
-The following example illustrates the contexts part of the event payload and omits other attributes for simplicity.
+The following example illustrates the contexts part of the event payload and omits other attributes for simplicity.
```json
{
diff --git a/develop-docs/sdk/data-model/event-payloads/debugmeta.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/debugmeta.mdx
similarity index 99%
rename from develop-docs/sdk/data-model/event-payloads/debugmeta.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/debugmeta.mdx
index 30f4f65dc5a1f..d25086e31c868 100644
--- a/develop-docs/sdk/data-model/event-payloads/debugmeta.mdx
+++ b/develop-docs/sdk/foundations/data-model/event-payloads/debugmeta.mdx
@@ -29,7 +29,7 @@ system symbols, and is not required for other SDKs.
## Debug Images
The list of debug images contains all dynamic libraries loaded into the process
-and their memory addresses. Instruction addresses in the [Stack Trace](/sdk/data-model/event-payloads/stacktrace/) are
+and their memory addresses. Instruction addresses in the [Stack Trace](/sdk/foundations/data-model/event-payloads/stacktrace/) are
mapped into the list of debug images in order to retrieve debug files for
symbolication.
diff --git a/develop-docs/sdk/data-model/event-payloads/exception.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/exception.mdx
similarity index 95%
rename from develop-docs/sdk/data-model/event-payloads/exception.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/exception.mdx
index 1c628ba63dbc9..5f427498dbb76 100644
--- a/develop-docs/sdk/data-model/event-payloads/exception.mdx
+++ b/develop-docs/sdk/foundations/data-model/event-payloads/exception.mdx
@@ -5,7 +5,7 @@ sidebar_order: 2
The Exception Interface specifies an exception or error that occurred in a program.
-An event may contain one or more exceptions in an attribute named `exception`.
+An event may contain one or more exceptions in an attribute named `exception`.
The `exception` attribute should be an object with the attribute `values`
containing a list of one or more values that are objects in the format described
@@ -41,7 +41,7 @@ description of `ValueError`.
`thread_id`
-: An optional value which refers to a thread in the [Thread Interface](/sdk/data-model/event-payloads/threads/).
+: An optional value which refers to a thread in the [Thread Interface](/sdk/foundations/data-model/event-payloads/threads/).
`mechanism`
@@ -50,7 +50,7 @@ created this exception.
`stacktrace`
-: An optional stack trace object corresponding to the [Stack Trace Interface](/sdk/data-model/event-payloads/stacktrace/).
+: An optional stack trace object corresponding to the [Stack Trace Interface](/sdk/foundations/data-model/event-payloads/stacktrace/).
## Exception Mechanism
The exception mechanism is an optional field residing in the _Exception Interface_.
@@ -120,11 +120,11 @@ function captureException(error, context) {
-Historically, there was no requirement for the `type` attribute naming scheme.
-Consequently, different SDKs took different approaches as to how they set the `type` attribute.
-In some cases, the `type` attribute was/is not set at all.
+Historically, there was no requirement for the `type` attribute naming scheme.
+Consequently, different SDKs took different approaches as to how they set the `type` attribute.
+In some cases, the `type` attribute was/is not set at all.
Choosing [Trace Origin](/sdk/performance/trace-origin/) as the naming scheme for the `type` attribute means that we're using an already established and accepted naming scheme.
-The scheme works well enough for the exception mechanism `type` attribute.
+The scheme works well enough for the exception mechanism `type` attribute.
Slight deviations to accommodate for the applicability to exceptions are allowed and to be expected.
SDK maintainers are free to migrate to the new naming scheme for existing capturing mechanisms or use it when adding new mechanisms.
@@ -285,7 +285,7 @@ information.
## Examples
The following examples illustrate multiple ways to send exceptions. Each example
-contains the exception part of the event payload and omits other
+contains the exception part of the event payload and omits other
attributes for simplicity.
A single exception:
diff --git a/develop-docs/sdk/data-model/event-payloads/index.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/index.mdx
similarity index 96%
rename from develop-docs/sdk/data-model/event-payloads/index.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/index.mdx
index d66cd597f282b..939d0307235b1 100644
--- a/develop-docs/sdk/data-model/event-payloads/index.mdx
+++ b/develop-docs/sdk/foundations/data-model/event-payloads/index.mdx
@@ -6,7 +6,7 @@ sidebar_order: 3
Events are the fundamental data that clients, often through the use of an SDK, send
to the Sentry server.
-Events are packed into [envelopes](/sdk/data-model/envelopes/) and are sent to the `/api/{PROJECT_ID}/envelope/` API endpoint.
+Events are packed into [envelopes](/sdk/foundations/data-model/envelopes/) and are sent to the `/api/{PROJECT_ID}/envelope/` API endpoint.
Sending event payloads to the `/api/{PROJECT_ID}/store/` API endpoint is deprecated.
@@ -285,7 +285,7 @@ Fingerprints](https://docs.sentry.io/data-management/event-grouping/).
## Size Limits
Event ingestion imposes limits on the size of events.
-See [Envelope Size Limits](/sdk/data-model/envelopes/#size-limits) for further details.
+See [Envelope Size Limits](/sdk/foundations/data-model/envelopes/#size-limits) for further details.
## Core Interfaces
diff --git a/develop-docs/sdk/data-model/event-payloads/lockreason.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/lockreason.mdx
similarity index 85%
rename from develop-docs/sdk/data-model/event-payloads/lockreason.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/lockreason.mdx
index ae85f391235c5..738130b89d0a2 100644
--- a/develop-docs/sdk/data-model/event-payloads/lockreason.mdx
+++ b/develop-docs/sdk/foundations/data-model/event-payloads/lockreason.mdx
@@ -8,7 +8,7 @@ to determine which other thread is holding the lock in case the current thread i
-Lock reasons are always part of a [thread](/sdk/data-model/event-payloads/threads/). They cannot be declared as a top-level event property.
+Lock reasons are always part of a [thread](/sdk/foundations/data-model/event-payloads/threads/). They cannot be declared as a top-level event property.
diff --git a/develop-docs/sdk/data-model/event-payloads/message.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/message.mdx
similarity index 97%
rename from develop-docs/sdk/data-model/event-payloads/message.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/message.mdx
index dad6d39c44fbe..7cce83bee9203 100644
--- a/develop-docs/sdk/data-model/event-payloads/message.mdx
+++ b/develop-docs/sdk/foundations/data-model/event-payloads/message.mdx
@@ -14,7 +14,7 @@ help to group similar messages into the same issue.
: **Required**. The fully formatted message. If missing, Sentry will try to
interpolate the message.
- A limit of 8192 characters is exposed in Relay and longer messages will be truncated.
+ A limit of 8192 characters is exposed in Relay and longer messages will be truncated.
SDKs should not enforce this limit.
Sentry also accepts a message where this is not set to support legacy SDKs.
diff --git a/develop-docs/sdk/data-model/event-payloads/properties/contexts_trace.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/properties/contexts_trace.mdx
similarity index 82%
rename from develop-docs/sdk/data-model/event-payloads/properties/contexts_trace.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/properties/contexts_trace.mdx
index 28144f6a6f2cc..0a39d118c5149 100644
--- a/develop-docs/sdk/data-model/event-payloads/properties/contexts_trace.mdx
+++ b/develop-docs/sdk/foundations/data-model/event-payloads/properties/contexts_trace.mdx
@@ -1,6 +1,6 @@
`contexts.trace`
-: _Recommended_. A Transaction has to have a specific `contexts.trace` entry that contains tracing information. See the [Trace Context documentation](/sdk/data-model/event-payloads/contexts/#trace-context).
+: _Recommended_. A Transaction has to have a specific `contexts.trace` entry that contains tracing information. See the [Trace Context documentation](/sdk/foundations/data-model/event-payloads/contexts/#trace-context).
```json
{
diff --git a/develop-docs/sdk/data-model/event-payloads/properties/description.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/properties/description.mdx
similarity index 100%
rename from develop-docs/sdk/data-model/event-payloads/properties/description.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/properties/description.mdx
diff --git a/develop-docs/sdk/data-model/event-payloads/properties/event_id.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/properties/event_id.mdx
similarity index 100%
rename from develop-docs/sdk/data-model/event-payloads/properties/event_id.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/properties/event_id.mdx
diff --git a/develop-docs/sdk/data-model/event-payloads/properties/measurements.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/properties/measurements.mdx
similarity index 100%
rename from develop-docs/sdk/data-model/event-payloads/properties/measurements.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/properties/measurements.mdx
diff --git a/develop-docs/sdk/data-model/event-payloads/properties/op.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/properties/op.mdx
similarity index 100%
rename from develop-docs/sdk/data-model/event-payloads/properties/op.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/properties/op.mdx
diff --git a/develop-docs/sdk/data-model/event-payloads/properties/parent_span_id.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/properties/parent_span_id.mdx
similarity index 100%
rename from develop-docs/sdk/data-model/event-payloads/properties/parent_span_id.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/properties/parent_span_id.mdx
diff --git a/develop-docs/sdk/data-model/event-payloads/properties/span_id.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/properties/span_id.mdx
similarity index 100%
rename from develop-docs/sdk/data-model/event-payloads/properties/span_id.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/properties/span_id.mdx
diff --git a/develop-docs/sdk/data-model/event-payloads/properties/span_start_timestamp.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/properties/span_start_timestamp.mdx
similarity index 100%
rename from develop-docs/sdk/data-model/event-payloads/properties/span_start_timestamp.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/properties/span_start_timestamp.mdx
diff --git a/develop-docs/sdk/data-model/event-payloads/properties/span_timestamp.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/properties/span_timestamp.mdx
similarity index 100%
rename from develop-docs/sdk/data-model/event-payloads/properties/span_timestamp.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/properties/span_timestamp.mdx
diff --git a/develop-docs/sdk/data-model/event-payloads/properties/spans.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/properties/spans.mdx
similarity index 90%
rename from develop-docs/sdk/data-model/event-payloads/properties/spans.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/properties/spans.mdx
index bc7cd56724749..423bf037fdb47 100644
--- a/develop-docs/sdk/data-model/event-payloads/properties/spans.mdx
+++ b/develop-docs/sdk/foundations/data-model/event-payloads/properties/spans.mdx
@@ -1,6 +1,6 @@
`spans`
-: _Recommended_. A list of [Spans](/sdk/data-model/event-payloads/span/).
+: _Recommended_. A list of [Spans](/sdk/foundations/data-model/event-payloads/span/).
```json
{
diff --git a/develop-docs/sdk/data-model/event-payloads/properties/status.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/properties/status.mdx
similarity index 100%
rename from develop-docs/sdk/data-model/event-payloads/properties/status.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/properties/status.mdx
diff --git a/develop-docs/sdk/data-model/event-payloads/properties/tags.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/properties/tags.mdx
similarity index 100%
rename from develop-docs/sdk/data-model/event-payloads/properties/tags.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/properties/tags.mdx
diff --git a/develop-docs/sdk/data-model/event-payloads/properties/trace_id.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/properties/trace_id.mdx
similarity index 100%
rename from develop-docs/sdk/data-model/event-payloads/properties/trace_id.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/properties/trace_id.mdx
diff --git a/develop-docs/sdk/data-model/event-payloads/properties/transaction_info.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/properties/transaction_info.mdx
similarity index 100%
rename from develop-docs/sdk/data-model/event-payloads/properties/transaction_info.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/properties/transaction_info.mdx
diff --git a/develop-docs/sdk/data-model/event-payloads/properties/type.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/properties/type.mdx
similarity index 100%
rename from develop-docs/sdk/data-model/event-payloads/properties/type.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/properties/type.mdx
diff --git a/develop-docs/sdk/data-model/event-payloads/replay-recording.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/replay-recording.mdx
similarity index 98%
rename from develop-docs/sdk/data-model/event-payloads/replay-recording.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/replay-recording.mdx
index c8f720e58e781..a11d60abb3608 100644
--- a/develop-docs/sdk/data-model/event-payloads/replay-recording.mdx
+++ b/develop-docs/sdk/foundations/data-model/event-payloads/replay-recording.mdx
@@ -76,7 +76,7 @@ The payload for `"options"` is a record of configuration name -> configuration v
### Breadcrumbs
-Breadcrumbs are named as such because they are intercepted from the web SDK and forwarded as a custom recording event. They have the same structure as describe in breadcrumbs interface.
+Breadcrumbs are named as such because they are intercepted from the web SDK and forwarded as a custom recording event. They have the same structure as describe in breadcrumbs interface.
```json
{
diff --git a/develop-docs/sdk/data-model/event-payloads/request.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/request.mdx
similarity index 100%
rename from develop-docs/sdk/data-model/event-payloads/request.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/request.mdx
diff --git a/develop-docs/sdk/data-model/event-payloads/sdk.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/sdk.mdx
similarity index 95%
rename from develop-docs/sdk/data-model/event-payloads/sdk.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/sdk.mdx
index 2a9f4c6d82a04..438546cd3b4e2 100644
--- a/develop-docs/sdk/data-model/event-payloads/sdk.mdx
+++ b/develop-docs/sdk/foundations/data-model/event-payloads/sdk.mdx
@@ -73,13 +73,13 @@ reference (branch, tag or SHA).
: _Optional_. A collection of settings that are used to control behaviour.
- `infer_ip`: Controls the behaviour of IP address inference based on request information. Following values are allowed:
- - `auto`: infer the IP address based on available request information. This is equal to [setting the IP address to `{{auto}}`](https://develop.sentry.dev/sdk/data-model/event-payloads/user/#automatic-ip-addresses).
+ - `auto`: infer the IP address based on available request information. This is equal to [setting the IP address to `{{auto}}`](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/user/#automatic-ip-addresses).
- `never`: Do not infer the IP address from the request. This is the default if an invalid value for `infer_ip` was sent.
- `legacy`: Infer the IP address only if the value is `{{auto}}`. For Javascript and Cocoa it will also infer if `ip_address` is empty. This is the default if no value was sent.
## Example
-The following example illustrates the SDK part of the event payload and omits other
+The following example illustrates the SDK part of the event payload and omits other
attributes for simplicity.
```json
diff --git a/develop-docs/sdk/data-model/event-payloads/span.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/span.mdx
similarity index 95%
rename from develop-docs/sdk/data-model/event-payloads/span.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/span.mdx
index 3f20fb4a229bd..4e3748e15cf3a 100644
--- a/develop-docs/sdk/data-model/event-payloads/span.mdx
+++ b/develop-docs/sdk/foundations/data-model/event-payloads/span.mdx
@@ -4,7 +4,7 @@ title: Span Interface
The Span Interface specifies a series of _timed_ application events that have a start and end time.
-A [Transaction](/sdk/data-model/event-payloads/transaction/) may contain zero or more Spans in an array attribute named `spans`. Spans in the list don't have to be ordered, they will be ordered by start / end time on the Server.
+A [Transaction](/sdk/foundations/data-model/event-payloads/transaction/) may contain zero or more Spans in an array attribute named `spans`. Spans in the list don't have to be ordered, they will be ordered by start / end time on the Server.
While Span attributes will be normalized on the server, a Span is most useful when it includes at least an `op` and `description`.
@@ -173,7 +173,7 @@ The semantic conventions for the `data` field are described in
Envelopes are a new format and therefore only work on Sentry >= 10. More
- information can be found on the Envelope page.
+ information can be found on the Envelope page.
## Anatomy
-A Transaction is basically a [Span](/sdk/data-model/event-payloads/span/) combined with an [Event](/sdk/data-model/event-payloads/). When using
+A Transaction is basically a [Span](/sdk/foundations/data-model/event-payloads/span/) combined with an [Event](/sdk/foundations/data-model/event-payloads/). When using
tracing with our SDKs you usually create a Span tree, the root node and therefore the whole tree is considered to be the Transaction.
-So technically a Transaction is just a Span. A Transaction must also have a `contexts.trace` (which contains some data of the [Span](/sdk/data-model/event-payloads/span/)) and some other
+So technically a Transaction is just a Span. A Transaction must also have a `contexts.trace` (which contains some data of the [Span](/sdk/foundations/data-model/event-payloads/span/)) and some other
properties that will be covered in the next section.
-Transactions are [Events](/sdk/data-model/event-payloads/) enriched with [Span](/sdk/data-model/event-payloads/span/) data.
+Transactions are [Events](/sdk/foundations/data-model/event-payloads/) enriched with [Span](/sdk/foundations/data-model/event-payloads/span/) data.
We are only going to list here what is important for a Transaction.
`type`
@@ -78,7 +78,7 @@ or:
`contexts.trace`
-_Recommended_. A Transaction has to have a specific `contexts.trace` entry that contains tracing information. See the [Trace Context documentation](/sdk/data-model/event-payloads/contexts/#trace-context).
+_Recommended_. A Transaction has to have a specific `contexts.trace` entry that contains tracing information. See the [Trace Context documentation](/sdk/foundations/data-model/event-payloads/contexts/#trace-context).
```json
{
@@ -97,7 +97,7 @@ _Recommended_. A Transaction has to have a specific `contexts.trace` entry that
`spans`
-_Recommended_. A list of [Spans](/sdk/data-model/event-payloads/span/).
+_Recommended_. A list of [Spans](/sdk/foundations/data-model/event-payloads/span/).
```json
{
diff --git a/develop-docs/sdk/data-model/event-payloads/user.mdx b/develop-docs/sdk/foundations/data-model/event-payloads/user.mdx
similarity index 95%
rename from develop-docs/sdk/data-model/event-payloads/user.mdx
rename to develop-docs/sdk/foundations/data-model/event-payloads/user.mdx
index e2ab817f01586..a5410199fc972 100644
--- a/develop-docs/sdk/data-model/event-payloads/user.mdx
+++ b/develop-docs/sdk/foundations/data-model/event-payloads/user.mdx
@@ -65,7 +65,7 @@ Approximate geographical location of the end user or device.
SDKs running on client platforms, such as browsers and mobile applications,
should set `ip_address = "{{auto}}"` by default. Server-side SDKs should
-populate the [Request Interface](/sdk/data-model/event-payloads/request/), instead. Sentry
+populate the [Request Interface](/sdk/foundations/data-model/event-payloads/request/), instead. Sentry
employs several fallbacks to backfill the IP address:
1. Use `user.ip_address`, if set directly.
diff --git a/develop-docs/sdk/data-model/index.mdx b/develop-docs/sdk/foundations/data-model/index.mdx
similarity index 100%
rename from develop-docs/sdk/data-model/index.mdx
rename to develop-docs/sdk/foundations/data-model/index.mdx
diff --git a/develop-docs/sdk/foundations/transport/rate-limiting.mdx b/develop-docs/sdk/foundations/transport/rate-limiting.mdx
index 7cebc01b4f23b..f9a53fc745c36 100644
--- a/develop-docs/sdk/foundations/transport/rate-limiting.mdx
+++ b/develop-docs/sdk/foundations/transport/rate-limiting.mdx
@@ -15,7 +15,7 @@ Each *quota_limit* has the form `retry_after:categories:scope:reason_code:namesp
- `retry_after`: Number of seconds (as an integer or a floating point number) until this rate limit expires.
- `categories`: Semicolon-separated list of [data categories](https://github.com/getsentry/relay/blob/master/relay-base-schema/src/data_category.rs#L91). **If empty, this limit applies to all categories**.
- While these categories might look similar to the [envelope item types](/sdk/foundations/transport/envelope-items/), they are not identical, and have slight differences.
+ While these categories might look similar to the [envelope item types](/sdk/foundations/data-model/envelope-items/), they are not identical, and have slight differences.
- `scope`: The scope that this limit applies to. Can be ignored by SDKs.
- `reason_code`: A unique identifier for the quota hinting at the rate limiting reason. Can be ignored by SDKs.
- `namespaces`: Semicolon-separated list of metric namespace identifiers. This will only be present if the rate limit applies to the `metric_bucket` data category. If the namespace is not present, the backoff applies to all metrics.
@@ -83,7 +83,7 @@ Guidelines for how SDKs should determine the current rate limits:
As stated earlier, SDKs can ignore the `scope` dimension. These definitions are here as a supplement to explain what the `X-Sentry-Rate-Limits` header is made of.
- **Category:** Classifies the type of data that is being counted. Arbitrary categories can be added as long as they can be inferred from the event or data being ingested.
-While these [data categories](https://github.com/getsentry/relay/blob/master/relay-base-schema/src/data_category.rs#L91) might look similar to the [envelope item types](/sdk/foundations/transport/envelope-items/), they are not identical, and have slight differences.
+While these [data categories](https://github.com/getsentry/relay/blob/master/relay-base-schema/src/data_category.rs#L91) might look similar to the [envelope item types](/sdk/foundations/data-model/envelope-items/), they are not identical, and have slight differences.
- `default`: Events with an event_type not listed explicitly below.
- `error`: Error events.
- `transaction`: Transaction type events.
diff --git a/develop-docs/sdk/miscellaneous/store.mdx b/develop-docs/sdk/miscellaneous/store.mdx
index 46ebc8e20c098..d89b7e8991f77 100644
--- a/develop-docs/sdk/miscellaneous/store.mdx
+++ b/develop-docs/sdk/miscellaneous/store.mdx
@@ -5,7 +5,7 @@ sidebar_order: 2
-The `/store` endpoint is deprecated. All data should be sent to the `/envelope` endpoint. See [Envelopes](/sdk/data-model/envelopes/).
+The `/store` endpoint is deprecated. All data should be sent to the `/envelope` endpoint. See [Envelopes](/sdk/foundations/data-model/envelopes/).
@@ -43,7 +43,7 @@ between them is that attributes are very barebones key/value pairs (for the
most part) and interfaces are rich styled interface elements. Examples of
attribute are `event_id` or `tags` whereas the `exception` key is an interface.
-For a list of all supported attributes and interfaces in event payloads, see Event Payloads.
+For a list of all supported attributes and interfaces in event payloads, see Event Payloads.
## HTTP Headers
diff --git a/develop-docs/sdk/miscellaneous/unified-api/index.mdx b/develop-docs/sdk/miscellaneous/unified-api/index.mdx
index dc17d72d8f279..e4dbbef70ec61 100644
--- a/develop-docs/sdk/miscellaneous/unified-api/index.mdx
+++ b/develop-docs/sdk/miscellaneous/unified-api/index.mdx
@@ -67,7 +67,7 @@ meant that certain integrations (such as breadcrumbs) were often not possible.
- **client options**: Are parameters that are language and runtime specific and used to configure the client. This can be release and environment but also things like which integrations to configure, how in-app works etc.
-- **context**: Contexts give extra data to Sentry. There are the special contexts (user and similar) and the generic ones (`runtime`, `os`, `device`), etc. Check out Contexts for some predefined keys - users can also add arbitrary context keys. _Note: In older SDKs, you might encounter an unrelated concept of context, which is now deprecated by scopes_
+- **context**: Contexts give extra data to Sentry. There are the special contexts (user and similar) and the generic ones (`runtime`, `os`, `device`), etc. Check out Contexts for some predefined keys - users can also add arbitrary context keys. _Note: In older SDKs, you might encounter an unrelated concept of context, which is now deprecated by scopes_
- **tags**: Tags can be arbitrary string→string pairs by which events can be searched. Contexts are converted into tags.
diff --git a/develop-docs/sdk/processes/basics.mdx b/develop-docs/sdk/processes/basics.mdx
index 4e20a771538c7..4dcdc03b59eb3 100644
--- a/develop-docs/sdk/processes/basics.mdx
+++ b/develop-docs/sdk/processes/basics.mdx
@@ -54,7 +54,7 @@ Before shipping new or changed SDK behavior, make sure the relevant definitions
2. Get an approval from at least one code owner.
3. Wait at least 3 business days after the first approval to give other code owners a chance to review.
-- **Context types:** Any newly added [context](https://develop.sentry.dev/sdk/data-model/event-payloads/contexts/) **SHOULD** also be typed out in [Relay](https://github.com/getsentry/relay/tree/master/relay-event-schema/src/protocol/contexts) so that the schema stays in sync with what SDKs emit.
+- **Context types:** Any newly added [context](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/contexts/) **SHOULD** also be typed out in [Relay](https://github.com/getsentry/relay/tree/master/relay-event-schema/src/protocol/contexts) so that the schema stays in sync with what SDKs emit.
## Join us on Discord
diff --git a/develop-docs/sdk/research/performance/index.mdx b/develop-docs/sdk/research/performance/index.mdx
index d2311d9b9bc82..88beace816c26 100644
--- a/develop-docs/sdk/research/performance/index.mdx
+++ b/develop-docs/sdk/research/performance/index.mdx
@@ -14,7 +14,7 @@ After settling with an API, performance monitoring support was then expanded to
Our initial implementation reused the mechanisms we had in place for error reporting:
-- The [Event type](https://develop.sentry.dev/sdk/data-model/event-payloads/) was extended with new fields. That meant that instead of designing and implementing a whole new ingestion pipeline, we could save time and quickly start sending "events" to Sentry, this time, instead of errors, a new "transaction" event type.
+- The [Event type](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/) was extended with new fields. That meant that instead of designing and implementing a whole new ingestion pipeline, we could save time and quickly start sending "events" to Sentry, this time, instead of errors, a new "transaction" event type.
- Since we were just sending a new type of event, the SDK transport layer was also reused.
- And since we were sharing the ingestion pipeline, that meant we were sharing storage and the many parts of the processing that happens to all events.
diff --git a/develop-docs/sdk/telemetry/check-ins.mdx b/develop-docs/sdk/telemetry/check-ins.mdx
index 1008af27047bc..d9dfaa08cdee3 100644
--- a/develop-docs/sdk/telemetry/check-ins.mdx
+++ b/develop-docs/sdk/telemetry/check-ins.mdx
@@ -66,7 +66,7 @@ The following fields exist:
`contexts`
: _Object, optional_. A dictionary of contextual information about the environment running
- the check-in. Right now we only support the [trace context](/sdk/data-model/event-payloads/contexts/#trace-context)
+ the check-in. Right now we only support the [trace context](/sdk/foundations/data-model/event-payloads/contexts/#trace-context)
and use the `trace_id` in order to link check-ins to associated errors.
## Monitor upsert support
diff --git a/develop-docs/sdk/telemetry/feedbacks.mdx b/develop-docs/sdk/telemetry/feedbacks.mdx
index 81fab475e7414..addabf09150c1 100644
--- a/develop-docs/sdk/telemetry/feedbacks.mdx
+++ b/develop-docs/sdk/telemetry/feedbacks.mdx
@@ -7,7 +7,7 @@ This document is meant for Sentry SDK developers and maintainers of the Feedback
## Feedback Protocol
-Item type `"feedback"`. This Item contains an [event payload](/sdk/data-model/event-payloads/) encoded in JSON, with an additional `feedback` context object.
+Item type `"feedback"`. This Item contains an [event payload](/sdk/foundations/data-model/event-payloads/) encoded in JSON, with an additional `feedback` context object.
## `"feedback"` Item
@@ -24,8 +24,8 @@ Item type `"feedback"`. This Item contains an [event payload](/sdk/data-model/ev
### Event Attributes
-Below is a recap of the [required attributes](/sdk/data-model/event-payloads/#required-attributes) for the event payload.
-For the full list of attributes, see [Event Payloads](/sdk/data-model/event-payloads/).
+Below is a recap of the [required attributes](/sdk/foundations/data-model/event-payloads/#required-attributes) for the event payload.
+For the full list of attributes, see [Event Payloads](/sdk/foundations/data-model/event-payloads/).
| Key | Type | Description |
| -------------------------- | ------ | ----------------------------------------------- |
@@ -55,7 +55,7 @@ For the full list of attributes, see [Event Payloads](/sdk/data-model/event-payl
### Attaching Files
You can attach files of any type to a feedback (screenshots, logs, documents, etc.) by sending them as
-[attachment items](/sdk/data-model/envelope-items/#attachment), with `event_id`
+[attachment items](/sdk/foundations/data-model/envelope-items/#attachment), with `event_id`
corresponding to the feedback item. We recommend sending the attachment items in the same
Envelope as the feedback item.
diff --git a/develop-docs/sdk/telemetry/logs.mdx b/develop-docs/sdk/telemetry/logs.mdx
index dfc0f07346bf5..9665021793afa 100644
--- a/develop-docs/sdk/telemetry/logs.mdx
+++ b/develop-docs/sdk/telemetry/logs.mdx
@@ -13,7 +13,7 @@ All SDKs are required to send logs via the `log` envelope and Sentry Log protoco
### `log` Envelope Item
-The `log` envelope item is an object that contains an array of log payloads encoded as JSON. This allows for multiple log payloads to be sent in a single envelope item. For more details on the `log` envelope item, see the [Log Envelope Item](/sdk/data-model/envelope-items/#log) documentation. See [Appendix A](#appendix-a-log-envelope-item-payload) for an example `log` envelope.
+The `log` envelope item is an object that contains an array of log payloads encoded as JSON. This allows for multiple log payloads to be sent in a single envelope item. For more details on the `log` envelope item, see the [Log Envelope Item](/sdk/foundations/data-model/envelope-items/#log) documentation. See [Appendix A](#appendix-a-log-envelope-item-payload) for an example `log` envelope.
```json
{
@@ -320,9 +320,9 @@ Logs can be generated in three ways:
SDKs may optionally attach user information as attributes (guarded by `sendDefaultPii`):
-1. `user.id`: The user ID. Maps to `id` in the [User](/sdk/data-model/event-payloads/user/) payload.
-2. `user.name`: The username. Maps to `username` in the [User](/sdk/data-model/event-payloads/user/) payload.
-3. `user.email`: The email address. Maps to `email` in the [User](/sdk/data-model/event-payloads/user/) payload.
+1. `user.id`: The user ID. Maps to `id` in the [User](/sdk/foundations/data-model/event-payloads/user/) payload.
+2. `user.name`: The username. Maps to `username` in the [User](/sdk/foundations/data-model/event-payloads/user/) payload.
+3. `user.email`: The email address. Maps to `email` in the [User](/sdk/foundations/data-model/event-payloads/user/) payload.
```json
{
@@ -338,8 +338,8 @@ SDKs may optionally attach user information as attributes (guarded by `sendDefau
By default, Relay should parse the user agent attached to an incoming log envelope to parse `browser` and `os` information for logs. These attributes should be attached by Relay, but SDKs can attach them if they do not forward a user agent when sending logs to Sentry.
-1. `browser.name`: Display name of the browser application. Maps to `name` in the [Contexts](/sdk/data-model/event-payloads/contexts/#browser-context) payload.
-2. `browser.version`: Version string of the browser. Maps to `version` in the [Contexts](/sdk/data-model/event-payloads/contexts/#browser-context) payload.
+1. `browser.name`: Display name of the browser application. Maps to `name` in the [Contexts](/sdk/foundations/data-model/event-payloads/contexts/#browser-context) payload.
+2. `browser.version`: Version string of the browser. Maps to `version` in the [Contexts](/sdk/foundations/data-model/event-payloads/contexts/#browser-context) payload.
```json
{
@@ -354,7 +354,7 @@ By default, Relay should parse the user agent attached to an incoming log envelo
For backend SDKs (Node.js, Python, PHP, etc.), the SDKs should attach the following:
-1. `server.address`: The address of the server that sent the log. Equivalent to [`server_name`](/sdk/data-model/event-payloads/#optional-attributes) we attach to errors and transactions.
+1. `server.address`: The address of the server that sent the log. Equivalent to [`server_name`](/sdk/foundations/data-model/event-payloads/#optional-attributes) we attach to errors and transactions.
```json
{
@@ -368,11 +368,11 @@ For backend SDKs (Node.js, Python, PHP, etc.), the SDKs should attach the follow
For mobile, desktop, and native SDKs (Android, Apple, Electron, etc.), the SDKs should attach the following:
-1. `os.name`: The name of the operating system. Maps to `name` in the [Contexts](/sdk/data-model/event-payloads/contexts/#os-context) payload.
-2. `os.version`: The version of the operating system. Maps to `version` in the [Contexts](/sdk/data-model/event-payloads/contexts/#os-context) payload.
-3. `device.brand`: The brand of the device. Maps to `brand` in the [Contexts](/sdk/data-model/event-payloads/contexts/#device-context) payload.
-4. `device.model`: The model of the device. Maps to `model` in the [Contexts](/sdk/data-model/event-payloads/contexts/#device-context) payload.
-5. `device.family`: The family of the device. Maps to `family` in the [Contexts](/sdk/data-model/event-payloads/contexts/#device-context) payload.
+1. `os.name`: The name of the operating system. Maps to `name` in the [Contexts](/sdk/foundations/data-model/event-payloads/contexts/#os-context) payload.
+2. `os.version`: The version of the operating system. Maps to `version` in the [Contexts](/sdk/foundations/data-model/event-payloads/contexts/#os-context) payload.
+3. `device.brand`: The brand of the device. Maps to `brand` in the [Contexts](/sdk/foundations/data-model/event-payloads/contexts/#device-context) payload.
+4. `device.model`: The model of the device. Maps to `model` in the [Contexts](/sdk/foundations/data-model/event-payloads/contexts/#device-context) payload.
+5. `device.family`: The family of the device. Maps to `family` in the [Contexts](/sdk/foundations/data-model/event-payloads/contexts/#device-context) payload.
```json
{
diff --git a/develop-docs/sdk/telemetry/metrics.mdx b/develop-docs/sdk/telemetry/metrics.mdx
index fd7c5b6ac9d3e..1e84bf92631cb 100644
--- a/develop-docs/sdk/telemetry/metrics.mdx
+++ b/develop-docs/sdk/telemetry/metrics.mdx
@@ -395,9 +395,9 @@ By default the SDK should attach the following attributes to a metric:
SDKs may optionally attach user information as attributes (guarded by `sendDefaultPii` [unless manually set by user](/sdk/expected-features/data-handling/#sensitive-data)):
-1. `user.id`: The user ID. Maps to `id` in the [User](/sdk/data-model/event-payloads/user/) payload.
-2. `user.name`: The username. Maps to `username` in the [User](/sdk/data-model/event-payloads/user/) payload.
-3. `user.email`: The email address. Maps to `email` in the [User](/sdk/data-model/event-payloads/user/) payload.
+1. `user.id`: The user ID. Maps to `id` in the [User](/sdk/foundations/data-model/event-payloads/user/) payload.
+2. `user.name`: The username. Maps to `username` in the [User](/sdk/foundations/data-model/event-payloads/user/) payload.
+3. `user.email`: The email address. Maps to `email` in the [User](/sdk/foundations/data-model/event-payloads/user/) payload.
```json
{
@@ -413,8 +413,8 @@ SDKs may optionally attach user information as attributes (guarded by `sendDefau
By default, Relay should parse the user agent attached to an incoming metric envelope to parse `browser` and `os` information for metrics. These attributes should be attached by Relay, but client-side SDKs can attach them if they do not forward a user agent when sending metrics to Sentry.
-1. `browser.name`: Display name of the browser application. Maps to `name` in the [Contexts](/sdk/data-model/event-payloads/contexts/#browser-context) payload.
-2. `browser.version`: Version string of the browser. Maps to `version` in the [Contexts](/sdk/data-model/event-payloads/contexts/#browser-context) payload.
+1. `browser.name`: Display name of the browser application. Maps to `name` in the [Contexts](/sdk/foundations/data-model/event-payloads/contexts/#browser-context) payload.
+2. `browser.version`: Version string of the browser. Maps to `version` in the [Contexts](/sdk/foundations/data-model/event-payloads/contexts/#browser-context) payload.
```json
{
@@ -429,7 +429,7 @@ By default, Relay should parse the user agent attached to an incoming metric env
For backend SDKs (Node.js, Python, PHP, etc.), the SDKs should attach the following:
-1. `server.address`: The address of the server that sent the metric. Equivalent to [`server_name`](/sdk/data-model/event-payloads/#optional-attributes) we attach to errors and transactions.
+1. `server.address`: The address of the server that sent the metric. Equivalent to [`server_name`](/sdk/foundations/data-model/event-payloads/#optional-attributes) we attach to errors and transactions.
```json
{
diff --git a/develop-docs/sdk/telemetry/profiles/sample-format-v1.mdx b/develop-docs/sdk/telemetry/profiles/sample-format-v1.mdx
index cf6aeded675e8..a2fbed3ccf202 100644
--- a/develop-docs/sdk/telemetry/profiles/sample-format-v1.mdx
+++ b/develop-docs/sdk/telemetry/profiles/sample-format-v1.mdx
@@ -83,7 +83,7 @@ in the same envelope as the associated transaction.
`debug_meta`
-: *Object, required on native platforms.* This carries the same payload as the [`debug_meta` interface](/sdk/data-model/event-payloads/sdk/).
+: *Object, required on native platforms.* This carries the same payload as the [`debug_meta` interface](/sdk/foundations/data-model/event-payloads/sdk/).
It is required to have it for native platforms in order to symbolicate. For non-native platforms, you can omit this.
`device`
@@ -342,7 +342,7 @@ the same `stack_id` for each sample that needs it.
`frames`
-: *List, required*. Contains a list of frame objects (see [Frame Attributes](/sdk/data-model/event-payloads/stacktrace/#frame-attributes)).
+: *List, required*. Contains a list of frame objects (see [Frame Attributes](/sdk/foundations/data-model/event-payloads/stacktrace/#frame-attributes)).
Each object should contain at least a `filename`, `function` or
`instruction_addr` attribute. All values are optional, but recommended.
@@ -404,8 +404,8 @@ It's suggested to remove unnecessary data like thread data without samples from
## Ingestion
After this payload is generated, serialize it as JSON, pack it into the same
-[Envelope](/sdk/data-model/envelopes/) as the associated transaction with the item type
-[`profile`](/sdk/data-model/envelope-items/#profile) and send it to Relay.
+[Envelope](/sdk/foundations/data-model/envelopes/) as the associated transaction with the item type
+[`profile`](/sdk/foundations/data-model/envelope-items/#profile) and send it to Relay.
This envelope should look like this:
diff --git a/develop-docs/sdk/telemetry/profiles/sample-format-v2.mdx b/develop-docs/sdk/telemetry/profiles/sample-format-v2.mdx
index cc0fa464dc379..59fc2370a71ec 100644
--- a/develop-docs/sdk/telemetry/profiles/sample-format-v2.mdx
+++ b/develop-docs/sdk/telemetry/profiles/sample-format-v2.mdx
@@ -64,7 +64,7 @@ The *Sample Format V2* is designed for use in continuous profiling. Therefore, a
`debug_meta`
-: *Object, required on native platforms.* This carries the same payload as the [`debug_meta` interface](/sdk/data-model/event-payloads/sdk/).
+: *Object, required on native platforms.* This carries the same payload as the [`debug_meta` interface](/sdk/foundations/data-model/event-payloads/sdk/).
It is required to have it for native platforms in order to symbolicate, otherwise you can omit it.
For non-native platforms, you can omit this.
@@ -223,7 +223,7 @@ the same `stack_id` for each sample that needs it.
`frames`
-: *List, required*. Contains a list of frame objects (see [Frame Attributes](/sdk/data-model/event-payloads/stacktrace/#frame-attributes)).
+: *List, required*. Contains a list of frame objects (see [Frame Attributes](/sdk/foundations/data-model/event-payloads/stacktrace/#frame-attributes)).
Each object should contain at least a `filename`, `function` or
`instruction_addr` attribute. All values are optional, but recommended.
@@ -280,7 +280,7 @@ It's suggested to remove unnecessary data like thread data without samples from
## Ingestion
-After this payload is generated, serialize it as JSON, pack it into an [Envelope](/sdk/data-model/envelopes/) with the item type [`profile_chunk`](/sdk/data-model/envelope-items/#profile-chunk) and send it to Relay.
+After this payload is generated, serialize it as JSON, pack it into an [Envelope](/sdk/foundations/data-model/envelopes/) with the item type [`profile_chunk`](/sdk/foundations/data-model/envelope-items/#profile-chunk) and send it to Relay.
The `platform` item header is required for rate limiting and categorization of the profile chunk and must match the `platform` in the payload.
diff --git a/develop-docs/sdk/telemetry/replays.mdx b/develop-docs/sdk/telemetry/replays.mdx
index e3d8ec495be60..3b6664d03bffa 100644
--- a/develop-docs/sdk/telemetry/replays.mdx
+++ b/develop-docs/sdk/telemetry/replays.mdx
@@ -19,7 +19,7 @@ The following attributes are specific to the `"replay_event"` Item type.
| Key | Type | Description |
| ---------------------- | ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| type | `"replay_event"` | Must be `"replay_event"` |
-| replay_id | string | A unique ID for the replay. Follows the [same requirements](/sdk/data-model/event-payloads/#required-attributes) as an `event_id`: Hexadecimal string representing a uuid4 value. The length is exactly 32 characters. Dashes are not allowed. Has to be lowercase. |
+| replay_id | string | A unique ID for the replay. Follows the [same requirements](/sdk/foundations/data-model/event-payloads/#required-attributes) as an `event_id`: Hexadecimal string representing a uuid4 value. The length is exactly 32 characters. Dashes are not allowed. Has to be lowercase. |
| replay_type | `"session"` \| `"buffer"` | Describes the type of replay. `buffer` means the replay is buffered while waiting for an error to occur or until a manual flush. `session` means the replay starts recording immediately and continues through the lifespan of the replay session. |
| segment_id | number | The segment id. |
| replay_start_timestamp | number | UNIX timestamp of the start of the replay (in seconds). This is only required on the first segment. |
@@ -29,7 +29,7 @@ The following attributes are specific to the `"replay_event"` Item type.
### Event Attributes
-The following attributes are a subset of the [optional attributes](/sdk/data-model/event-payloads/#optional-attributes) of an Event.
+The following attributes are a subset of the [optional attributes](/sdk/foundations/data-model/event-payloads/#optional-attributes) of an Event.
| Key | Type | Description |
| -------------------------- | ------ | ------------------------------------------------ |
@@ -100,7 +100,7 @@ The `"replay_recording"` item consists of two sub-items that are delimited by ne
{"segment_id": 0}
```
-The other sub-item is the replay recording's instructions set. This payload should be gzipped, but uncompressed payloads are also accepted. Read more about replay recording events here.
+The other sub-item is the replay recording's instructions set. This payload should be gzipped, but uncompressed payloads are also accepted. Read more about replay recording events here.
```json
[
diff --git a/develop-docs/sdk/telemetry/sessions/index.mdx b/develop-docs/sdk/telemetry/sessions/index.mdx
index d1c7235a0f019..e56903eb9d5f6 100644
--- a/develop-docs/sdk/telemetry/sessions/index.mdx
+++ b/develop-docs/sdk/telemetry/sessions/index.mdx
@@ -10,7 +10,7 @@ Looking for Sentry's **Session Replay**? Click envelopes
+For basic health tracking Sentry accepts envelopes
containing session update events. These session update events can be used to
inform Sentry about release and project associated project health.
diff --git a/develop-docs/sdk/telemetry/spans/span-protocol.mdx b/develop-docs/sdk/telemetry/spans/span-protocol.mdx
index 63b83cb649255..dba07d008545d 100644
--- a/develop-docs/sdk/telemetry/spans/span-protocol.mdx
+++ b/develop-docs/sdk/telemetry/spans/span-protocol.mdx
@@ -26,7 +26,7 @@ There are no special requirements for the Span v2 envelope header.
}
```
-Also see [Envelope Headers](/sdk/data-model/envelopes/#headers).
+Also see [Envelope Headers](/sdk/foundations/data-model/envelopes/#headers).
## Span v2 Envelope Item Header
@@ -169,7 +169,7 @@ Empty attributes must be omitted.
| `sentry.environment` | string | The environment name (e.g., "production", "staging", "development") |
| `sentry.segment.name` | string | The segment name (e.g., "GET /users") |
| `sentry.segment.id` | string | The segment span id |
-| `sentry.span.source` | string | The source of the span name. **MUST** be set on segment spans, **MAY** be set on child spans.
See [Sentry Conventions](https://github.com/getsentry/sentry-conventions/attributes/sentry#sentry-span-source) for all supported sources.
See [Transaction Annotations](/sdk/data-model/event-payloads/transaction/#transaction-annotations) and [Clustering](/backend/application-domains/transaction-clustering/#automatic-transaction-clustering) for more information.|
+| `sentry.span.source` | string | The source of the span name. **MUST** be set on segment spans, **MAY** be set on child spans.
See [Sentry Conventions](https://github.com/getsentry/sentry-conventions/attributes/sentry#sentry-span-source) for all supported sources.
See [Transaction Annotations](/sdk/foundations/data-model/event-payloads/transaction/#transaction-annotations) and [Clustering](/backend/application-domains/transaction-clustering/#automatic-transaction-clustering) for more information.|
| `sentry.profiler_id` | string | The id of the currently running profiler (continuous profiling) |
| `sentry.replay_id` | string | The id of the currently running replay (if available) |
| `os.name` | string | The operating system name (e.g., "Linux", "Windows", "macOS") |
@@ -226,7 +226,7 @@ span_id: "438f40bd3b4a41ee"
Span attachments are an experimental feature that is still under development.
-To associate an attachment with a span, submit a [trace attachment](/sdk/data-model/envelope-items/#trace-attachment) item with an additional `span_id` item header. The trace attachment _should_ be submitted in the same envelope as the span itself.
+To associate an attachment with a span, submit a [trace attachment](/sdk/foundations/data-model/envelope-items/#trace-attachment) item with an additional `span_id` item header. The trace attachment _should_ be submitted in the same envelope as the span itself.
- `span_id` is the ID of the span that owns the attachment. If set, the attachment will be dropped with the span if the span is dropped by dynamic sampling, inbound filters or rate limits. That is, Relay treats `span_id` as the owner of the attachment.
- The SDK _may_ set the `span_id` item header to an explicit `null` value. `span_id: null` is treated as “owned by spans”, but not owned by a specific span. That is, the attachment can be dropped if the span quota is exceeded, but it will not be dropped with a specific span because of e.g. inbound filters.
diff --git a/develop-docs/sdk/telemetry/telemetry-processor/batch-processor.mdx b/develop-docs/sdk/telemetry/telemetry-processor/batch-processor.mdx
index 83a2fdb2a808b..4c9a7f9f161ce 100644
--- a/develop-docs/sdk/telemetry/telemetry-processor/batch-processor.mdx
+++ b/develop-docs/sdk/telemetry/telemetry-processor/batch-processor.mdx
@@ -28,7 +28,7 @@ Whenever the SDK finishes a span or captures a log, it **MUST** put it into the
The BatchProcessor **MUST** start a timeout of 5 seconds when the SDK adds the first span or log. When the timeout expires, the BatchProcessor **MUST** forward all spans or logs to the transport, no matter how many items it contains. The SDK **MAY** choose a different value for the timeout, but it **MUST NOT** exceed 30 seconds, as this can lead to problems with the span buffer on the backend, which uses a time interval of 60 seconds for determining segments for spans. The BatchProcessor **SHOULD** only start a new timeout when it has spans or logs to send, this avoids running the timeout unnecessarily.
-The BatchProcessor **MUST** forward all items to the transport after the SDK when containing spans or logs exceeding 1MiB in size. The SDK **MAY** choose a different value for the max batch size keeping the [envelope max sizes](/sdk/data-model/envelopes/#size-limits) in mind. The SDK **MUST** calculate the size of a span or a log to manage the BatchProcessor's memory footprint, as well as serialize the span or log and calculate the size based on the serialized JSON bytes. As serialization is expensive, the BatchProcessor **SHOULD** keep track of the serialized spans and logs and pass these to the envelope to avoid serializing multiple times.
+The BatchProcessor **MUST** forward all items to the transport after the SDK when containing spans or logs exceeding 1MiB in size. The SDK **MAY** choose a different value for the max batch size keeping the [envelope max sizes](/sdk/foundations/data-model/envelopes/#size-limits) in mind. The SDK **MUST** calculate the size of a span or a log to manage the BatchProcessor's memory footprint, as well as serialize the span or log and calculate the size based on the serialized JSON bytes. As serialization is expensive, the BatchProcessor **SHOULD** keep track of the serialized spans and logs and pass these to the envelope to avoid serializing multiple times.
When the BatchProcessor forwards all spans or logs to the transport, it **MUST** reset its timeout and remove all spans and logs. The SDK **MUST** apply filtering and sampling before adding spans or logs to the BatchProcessor. The SDK **MUST** apply rate limits to spans and logs after they leave the BatchProcessor to send as much data as possible by dropping data as late as possible.
diff --git a/develop-docs/sdk/telemetry/telemetry-processor/index.mdx b/develop-docs/sdk/telemetry/telemetry-processor/index.mdx
index 685989302d924..9553c946a7c61 100644
--- a/develop-docs/sdk/telemetry/telemetry-processor/index.mdx
+++ b/develop-docs/sdk/telemetry/telemetry-processor/index.mdx
@@ -104,7 +104,7 @@ SDKs **SHOULD** use the following size limits for the telemetry buffer. SDKs **M
- 100 items for metrics
- 1000 items for spans
-While the [envelope size limits](/sdk/data-model/envelopes/#size-limits) would allow higher size limits for specific categories, these limits are optimized for Relay and exceeding them is absolutely discouraged.
+While the [envelope size limits](/sdk/foundations/data-model/envelopes/#size-limits) would allow higher size limits for specific categories, these limits are optimized for Relay and exceeding them is absolutely discouraged.
## Data Forwarding Scenarios
diff --git a/develop-docs/sdk/telemetry/traces/dynamic-sampling-context.mdx b/develop-docs/sdk/telemetry/traces/dynamic-sampling-context.mdx
index 5a5d801fd236c..d9779d02b9a53 100644
--- a/develop-docs/sdk/telemetry/traces/dynamic-sampling-context.mdx
+++ b/develop-docs/sdk/telemetry/traces/dynamic-sampling-context.mdx
@@ -94,7 +94,7 @@ For that reason: **Only if a transaction name has good quality, it should be inc
- `"/organization/:organizationId/user/:userId"`
- `"UserListUIComponent"`
-SDKs can leverage transaction annotations (in particular the `source` of the transaction name) to determine which transaction names have a good quality.
+SDKs can leverage transaction annotations (in particular the `source` of the transaction name) to determine which transaction names have a good quality.
diff --git a/develop-docs/sdk/telemetry/traces/index.mdx b/develop-docs/sdk/telemetry/traces/index.mdx
index ea0876e25c2ad..e0ccde826811b 100644
--- a/develop-docs/sdk/telemetry/traces/index.mdx
+++ b/develop-docs/sdk/telemetry/traces/index.mdx
@@ -220,14 +220,14 @@ Over the wire, transactions are serialized to JSON as an augmented `Event`, and
In the Sentry UI, you can use Discover to look at all events regardless of type, and the Issues and Performance sections to dive into errors and transactions, respectively. The [user-facing tracing documentation](https://docs.sentry.io/product/performance/distributed-tracing/#traces-transactions-and-spans) explains more of the concepts on the product level.
-The [Span](/sdk/data-model/event-payloads/span/) class stores each individual span in a
+The [Span](/sdk/foundations/data-model/event-payloads/span/) class stores each individual span in a
trace.
-The [Transaction](/sdk/data-model/event-payloads/transaction/) class is like a span, with a
+The [Transaction](/sdk/foundations/data-model/event-payloads/transaction/) class is like a span, with a
few key differences:
- Transactions have `name`, spans don't.
-- Transactions must specify the [source](/sdk/data-model/event-payloads/transaction/#transaction-annotations) of its `name` to indicate how the transaction name was generated.
+- Transactions must specify the [source](/sdk/foundations/data-model/event-payloads/transaction/#transaction-annotations) of its `name` to indicate how the transaction name was generated.
- Calling the `finish` method on spans record the span's end timestamp. For
transactions, the `finish` method additionally sends an event to Sentry.
@@ -263,7 +263,7 @@ tree as well as the unit of reporting to Sentry.
- `super.finish()` (call finish on Span)
- Send it to Sentry only if `sampled == true`
- Like spans, can be given an optional `endTimestamp` value that should be passed into the `span.finish()` call
- - A `Transaction` needs to be wrapped in an `Envelope` and sent to the [Envelope Endpoint](/sdk/data-model/envelopes/)
+ - A `Transaction` needs to be wrapped in an `Envelope` and sent to the [Envelope Endpoint](/sdk/foundations/data-model/envelopes/)
- The `Transport` should use the same internal queue for `Transactions` / `Events`
- The `Transport` should implement category-based rate limiting →
- The `Transport` should deal with wrapping a `Transaction` in an `Envelope` internally
diff --git a/develop-docs/sdk/telemetry/traces/opentelemetry.mdx b/develop-docs/sdk/telemetry/traces/opentelemetry.mdx
index 622ef9ceb9191..2dcdccc544282 100644
--- a/develop-docs/sdk/telemetry/traces/opentelemetry.mdx
+++ b/develop-docs/sdk/telemetry/traces/opentelemetry.mdx
@@ -400,7 +400,7 @@ function generateSentryErrorsFromOtelSpan(otelSpan) {
## Span Protocol
-Below describe the transformations between an OpenTelemetry span and a Sentry Span. Related: [the interface for a Sentry Span](https://develop.sentry.dev/sdk/data-model/event-payloads/span/), [the Relay spec for a Sentry Span](https://github.com/getsentry/relay/blob/master/relay-event-schema/src/protocol/span.rs) and the spec for an [OpenTelemetry span](https://github.com/open-telemetry/opentelemetry-proto/blob/724e427879e3d2bae2edc0218fff06e37b9eb46e/opentelemetry/proto/trace/v1/trace.proto#L80-L256).
+Below describe the transformations between an OpenTelemetry span and a Sentry Span. Related: [the interface for a Sentry Span](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/span/), [the Relay spec for a Sentry Span](https://github.com/getsentry/relay/blob/master/relay-event-schema/src/protocol/span.rs) and the spec for an [OpenTelemetry span](https://github.com/open-telemetry/opentelemetry-proto/blob/724e427879e3d2bae2edc0218fff06e37b9eb46e/opentelemetry/proto/trace/v1/trace.proto#L80-L256).
This is based on a mapping done as part of work on the [OpenTelemetry Sentry Exporter](https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/exporter/sentryexporter/docs/transformation.md).
@@ -432,7 +432,7 @@ import {Span as OtelSpan} from '@opentelemetry/sdk-trace-base';
import {SemanticAttributes} from '@opentelemetry/semantic-conventions';
import {SpanStatusType as SentryStatus} from '@sentry/tracing';
-// canonicalCodesHTTPMap maps some HTTP codes to Sentry's span statuses. See possible mapping in https://develop.sentry.dev/sdk/data-model/event-payloads/span/
+// canonicalCodesHTTPMap maps some HTTP codes to Sentry's span statuses. See possible mapping in https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/span/
const canonicalCodesHTTPMap: Record = {
'400': 'failed_precondition',
'401': 'unauthenticated',
diff --git a/develop-docs/sdk/telemetry/traces/span-data-conventions.mdx b/develop-docs/sdk/telemetry/traces/span-data-conventions.mdx
index 6dd4a24e15085..0f14f676eef6e 100644
--- a/develop-docs/sdk/telemetry/traces/span-data-conventions.mdx
+++ b/develop-docs/sdk/telemetry/traces/span-data-conventions.mdx
@@ -38,7 +38,7 @@ Below describes the conventions for the Span interface for the `data` field on t
| Attribute | Type | Description | Examples |
| --------------------- | ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------- |
| `blocked_main_thread` | boolean | Whether the main thread was blocked by the span. | `true` |
-| `call_stack` | StackFrame[] | The most relevant stack frames, that lead to the File I/O span. The stack frame should adhere to the [`StackFrame`](https://develop.sentry.dev/sdk/data-model/event-payloads/stacktrace/#frame-attributes) interface. | |
+| `call_stack` | StackFrame[] | The most relevant stack frames, that lead to the File I/O span. The stack frame should adhere to the [`StackFrame`](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/stacktrace/#frame-attributes) interface. | |
| `url` | string | The URL of the resource that was fetched. | `https://example.com` |
| `type` | string | More granular type of the operation happening. | `fetch` |
| `frames.total` | int | The number of total frames rendered during the lifetime of the span. | `60` |
diff --git a/develop-docs/sdk/telemetry/traces/trace-origin.mdx b/develop-docs/sdk/telemetry/traces/trace-origin.mdx
index 7abce0ef131f3..626a941231bc8 100644
--- a/develop-docs/sdk/telemetry/traces/trace-origin.mdx
+++ b/develop-docs/sdk/telemetry/traces/trace-origin.mdx
@@ -4,7 +4,7 @@ title: Trace Origin
Trace origin indicates what created a trace, span or log. Not all traces, spans or logs contain enough information
to tell whether the user or what precisely in the SDK created it. Origin solves this problem. Origin can be sent with
-the trace context, spans, or logs.
+the trace context, spans, or logs.
For logs and standalone spans, the origin should be set as the `sentry.origin` attribute key.
@@ -62,7 +62,7 @@ automatically creates a span. In this case we end up with the following origins:
## See also:
-- Span Interface
-- Trace Context
+- Span Interface
+- Trace Context
- Logs Interface
- Related [RFC](https://github.com/getsentry/rfcs/pull/73/)
diff --git a/develop-docs/sdk/telemetry/traces/tracing-without-performance.mdx b/develop-docs/sdk/telemetry/traces/tracing-without-performance.mdx
index 000359aa57642..f0193a77ebedc 100644
--- a/develop-docs/sdk/telemetry/traces/tracing-without-performance.mdx
+++ b/develop-docs/sdk/telemetry/traces/tracing-without-performance.mdx
@@ -96,7 +96,7 @@ This means that:
### Attaching Trace Data to Events and Envelopes
-Any event created by an SDK in TwP mode must include the [`trace` context](/sdk/event-payloads/contexts/#trace-context).
+Any event created by an SDK in TwP mode must include the [`trace` context](/sdk/foundations/data-model/event-payloads/contexts/#trace-context).
This context should contain the trace data of the current trace, if available, just like in regular tracing mode.
Furthermore, the [`trace` envelope header](/sdk/telemetry/traces/dynamic-sampling-context/#envelope-header) (populated from the dynamic sampling context) must be attached to any outgoing event envelope.
diff --git a/docs/cli/send-event.mdx b/docs/cli/send-event.mdx
index d93fa5f9404f7..74b9698565227 100644
--- a/docs/cli/send-event.mdx
+++ b/docs/cli/send-event.mdx
@@ -69,7 +69,7 @@ sentry-cli send-event -m "a failure" -t task:create-user
## Stored Events
-As of version `1.71`, the `send-event` command can accept an optional argument that specifies a path to the stored JSON representation of an [event payload](https://develop.sentry.dev/sdk/data-model/event-payloads/). When used, it will load the file, validate the event and send it to Sentry.
+As of version `1.71`, the `send-event` command can accept an optional argument that specifies a path to the stored JSON representation of an [event payload](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/). When used, it will load the file, validate the event and send it to Sentry.
```bash
sentry-cli send-event ./events/20211029150006.json
diff --git a/docs/concepts/search/searchable-properties/events.mdx b/docs/concepts/search/searchable-properties/events.mdx
index 94d8e84c4e908..9e826df9f09a0 100644
--- a/docs/concepts/search/searchable-properties/events.mdx
+++ b/docs/concepts/search/searchable-properties/events.mdx
@@ -282,7 +282,7 @@ Returns results with the defined tag or field, but not the value of that tag or
### `http.method`
-HTTP method of the [request](https://develop.sentry.dev/sdk/data-model/event-payloads/request/) that created the event.
+HTTP method of the [request](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/request/) that created the event.
- **Type:** string
@@ -703,7 +703,7 @@ Short code identifying the [type of operation](https://develop.sentry.dev/sdk/pe
### `transaction.status`
-Describes the status of the span/transaction. Check out our [Transaction Payloads documentation](https://develop.sentry.dev/sdk/data-model/event-payloads/transaction/) for all possible statuses.
+Describes the status of the span/transaction. Check out our [Transaction Payloads documentation](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/transaction/) for all possible statuses.
- **Type:** string
diff --git a/docs/concepts/search/searchable-properties/issues.mdx b/docs/concepts/search/searchable-properties/issues.mdx
index 99499380f3e6f..caef0c1841abd 100644
--- a/docs/concepts/search/searchable-properties/issues.mdx
+++ b/docs/concepts/search/searchable-properties/issues.mdx
@@ -210,7 +210,7 @@ Returns results with the defined tag or field, but not the value of that tag or
### `http.method`
-HTTP method of the [request](https://develop.sentry.dev/sdk/data-model/event-payloads/request/) that created the event.
+HTTP method of the [request](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/request/) that created the event.
- **Type:** string
diff --git a/docs/platforms/android/configuration/filtering.mdx b/docs/platforms/android/configuration/filtering.mdx
index 5b1245e5c7d0a..63bcbe75639f9 100644
--- a/docs/platforms/android/configuration/filtering.mdx
+++ b/docs/platforms/android/configuration/filtering.mdx
@@ -8,7 +8,7 @@ When you add Sentry to your app, you get a lot of valuable information about err
The Sentry SDKs have several configuration options to help you filter out events.
-We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/data-model/event-payloads/).
+We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/).
## Filtering Error Events
diff --git a/docs/platforms/android/enriching-events/breadcrumbs/index.mdx b/docs/platforms/android/enriching-events/breadcrumbs/index.mdx
index 8b14c67b17bd9..12f8a347a24c7 100644
--- a/docs/platforms/android/enriching-events/breadcrumbs/index.mdx
+++ b/docs/platforms/android/enriching-events/breadcrumbs/index.mdx
@@ -11,7 +11,7 @@ This page provides an overview of manual breadcrumb recording and customization.
-Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/data-model/event-payloads/breadcrumbs/).
+Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/breadcrumbs/).
diff --git a/docs/platforms/android/enriching-events/context/index.mdx b/docs/platforms/android/enriching-events/context/index.mdx
index 36da3d54f7593..03727abdfb125 100644
--- a/docs/platforms/android/enriching-events/context/index.mdx
+++ b/docs/platforms/android/enriching-events/context/index.mdx
@@ -23,7 +23,7 @@ Then, use and give the context a uniqu
There are no restrictions on context name. In the context object, all keys are allowed except for `type`, which is used internally.
-Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/data-model/event-payloads/contexts/).
+Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/contexts/).
## Size Limitations
diff --git a/docs/platforms/apple/common/configuration/filtering.mdx b/docs/platforms/apple/common/configuration/filtering.mdx
index f184ba21aa98c..2b368bc864fd7 100644
--- a/docs/platforms/apple/common/configuration/filtering.mdx
+++ b/docs/platforms/apple/common/configuration/filtering.mdx
@@ -8,7 +8,7 @@ When you add Sentry to your app, you get a lot of valuable information about err
The Sentry SDKs have several configuration options to help you filter out events.
-We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/data-model/event-payloads/).
+We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/).
## Filtering Error Events
diff --git a/docs/platforms/apple/common/enriching-events/breadcrumbs/index.mdx b/docs/platforms/apple/common/enriching-events/breadcrumbs/index.mdx
index a80f773451614..dd5e3fdbff5f2 100644
--- a/docs/platforms/apple/common/enriching-events/breadcrumbs/index.mdx
+++ b/docs/platforms/apple/common/enriching-events/breadcrumbs/index.mdx
@@ -11,7 +11,7 @@ This page provides an overview of manual breadcrumb recording and customization.
-Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/data-model/event-payloads/breadcrumbs/).
+Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/breadcrumbs/).
diff --git a/docs/platforms/apple/common/enriching-events/context/index.mdx b/docs/platforms/apple/common/enriching-events/context/index.mdx
index 36da3d54f7593..03727abdfb125 100644
--- a/docs/platforms/apple/common/enriching-events/context/index.mdx
+++ b/docs/platforms/apple/common/enriching-events/context/index.mdx
@@ -23,7 +23,7 @@ Then, use and give the context a uniqu
There are no restrictions on context name. In the context object, all keys are allowed except for `type`, which is used internally.
-Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/data-model/event-payloads/contexts/).
+Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/contexts/).
## Size Limitations
diff --git a/docs/platforms/apple/common/migration/index.mdx b/docs/platforms/apple/common/migration/index.mdx
index 40be530e5ae82..7b1fbd90ec6c6 100644
--- a/docs/platforms/apple/common/migration/index.mdx
+++ b/docs/platforms/apple/common/migration/index.mdx
@@ -404,7 +404,7 @@ if (eventId != SentryId.empty) {
#### New type SentryMessage for Event.message
-In 6.x, we introduce a new type [SentryMessage](https://develop.sentry.dev/sdk/data-model/event-payloads/message/) for `event.message`. SentryMessage provides you the ability to pass a format string with parameters to Sentry, which can help group similar messages into the same issue.
+In 6.x, we introduce a new type [SentryMessage](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/message/) for `event.message`. SentryMessage provides you the ability to pass a format string with parameters to Sentry, which can help group similar messages into the same issue.
Example in 5.x:
diff --git a/docs/platforms/dart/common/configuration/filtering.mdx b/docs/platforms/dart/common/configuration/filtering.mdx
index cbfd6077f23ca..7d62ce9e00214 100644
--- a/docs/platforms/dart/common/configuration/filtering.mdx
+++ b/docs/platforms/dart/common/configuration/filtering.mdx
@@ -8,7 +8,7 @@ When you add Sentry to your app, you get a lot of valuable information about err
The Sentry SDKs have several configuration options to help you filter out events.
-We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/data-model/event-payloads/).
+We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/).
## Filtering Error Events
diff --git a/docs/platforms/dart/common/enriching-events/breadcrumbs/index.mdx b/docs/platforms/dart/common/enriching-events/breadcrumbs/index.mdx
index 8b14c67b17bd9..12f8a347a24c7 100644
--- a/docs/platforms/dart/common/enriching-events/breadcrumbs/index.mdx
+++ b/docs/platforms/dart/common/enriching-events/breadcrumbs/index.mdx
@@ -11,7 +11,7 @@ This page provides an overview of manual breadcrumb recording and customization.
-Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/data-model/event-payloads/breadcrumbs/).
+Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/breadcrumbs/).
diff --git a/docs/platforms/dart/common/enriching-events/context/index.mdx b/docs/platforms/dart/common/enriching-events/context/index.mdx
index 36da3d54f7593..03727abdfb125 100644
--- a/docs/platforms/dart/common/enriching-events/context/index.mdx
+++ b/docs/platforms/dart/common/enriching-events/context/index.mdx
@@ -23,7 +23,7 @@ Then, use and give the context a uniqu
There are no restrictions on context name. In the context object, all keys are allowed except for `type`, which is used internally.
-Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/data-model/event-payloads/contexts/).
+Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/contexts/).
## Size Limitations
diff --git a/docs/platforms/dart/guides/flutter/configuration/filtering.mdx b/docs/platforms/dart/guides/flutter/configuration/filtering.mdx
index 38ca91e3271c1..7b89b12888395 100644
--- a/docs/platforms/dart/guides/flutter/configuration/filtering.mdx
+++ b/docs/platforms/dart/guides/flutter/configuration/filtering.mdx
@@ -8,7 +8,7 @@ When you add Sentry to your app, you get a lot of valuable information about err
The Sentry SDKs have several configuration options to help you filter out events.
-We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/data-model/event-payloads/).
+We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/).
## Filtering Error Events
diff --git a/docs/platforms/dart/guides/flutter/enriching-events/breadcrumbs/index.mdx b/docs/platforms/dart/guides/flutter/enriching-events/breadcrumbs/index.mdx
index 8b14c67b17bd9..12f8a347a24c7 100644
--- a/docs/platforms/dart/guides/flutter/enriching-events/breadcrumbs/index.mdx
+++ b/docs/platforms/dart/guides/flutter/enriching-events/breadcrumbs/index.mdx
@@ -11,7 +11,7 @@ This page provides an overview of manual breadcrumb recording and customization.
-Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/data-model/event-payloads/breadcrumbs/).
+Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/breadcrumbs/).
diff --git a/docs/platforms/dart/guides/flutter/enriching-events/context/index.mdx b/docs/platforms/dart/guides/flutter/enriching-events/context/index.mdx
index 36da3d54f7593..03727abdfb125 100644
--- a/docs/platforms/dart/guides/flutter/enriching-events/context/index.mdx
+++ b/docs/platforms/dart/guides/flutter/enriching-events/context/index.mdx
@@ -23,7 +23,7 @@ Then, use and give the context a uniqu
There are no restrictions on context name. In the context object, all keys are allowed except for `type`, which is used internally.
-Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/data-model/event-payloads/contexts/).
+Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/contexts/).
## Size Limitations
diff --git a/docs/platforms/dotnet/common/configuration/filtering.mdx b/docs/platforms/dotnet/common/configuration/filtering.mdx
index ccfb6cdf672a6..bf4f2092f4802 100644
--- a/docs/platforms/dotnet/common/configuration/filtering.mdx
+++ b/docs/platforms/dotnet/common/configuration/filtering.mdx
@@ -8,7 +8,7 @@ When you add Sentry to your app, you get a lot of valuable information about err
The Sentry SDKs have several configuration options to help you filter out events.
-We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/data-model/event-payloads/).
+We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/).
## Filtering Error Events
diff --git a/docs/platforms/dotnet/common/enriching-events/breadcrumbs/index.mdx b/docs/platforms/dotnet/common/enriching-events/breadcrumbs/index.mdx
index 95a268ad88192..2436ef02f1f2c 100644
--- a/docs/platforms/dotnet/common/enriching-events/breadcrumbs/index.mdx
+++ b/docs/platforms/dotnet/common/enriching-events/breadcrumbs/index.mdx
@@ -11,7 +11,7 @@ This page provides an overview of manual breadcrumb recording and customization.
-Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/data-model/event-payloads/breadcrumbs/).
+Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/breadcrumbs/).
diff --git a/docs/platforms/dotnet/common/enriching-events/context/index.mdx b/docs/platforms/dotnet/common/enriching-events/context/index.mdx
index 3c36bc77e1f8b..34e651925945d 100644
--- a/docs/platforms/dotnet/common/enriching-events/context/index.mdx
+++ b/docs/platforms/dotnet/common/enriching-events/context/index.mdx
@@ -23,7 +23,7 @@ Then, use `Contexts` and give the context a unique name:
There are no restrictions on context name. In the context object, all keys are allowed except for `type`, which is used internally.
-Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/data-model/event-payloads/contexts/).
+Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/contexts/).
## Size Limitations
diff --git a/docs/platforms/elixir/configuration/filtering.mdx b/docs/platforms/elixir/configuration/filtering.mdx
index d97ca31054711..c4962c19dba8e 100644
--- a/docs/platforms/elixir/configuration/filtering.mdx
+++ b/docs/platforms/elixir/configuration/filtering.mdx
@@ -8,7 +8,7 @@ When you add Sentry to your app, you get a lot of valuable information about err
The Sentry SDKs have several configuration options to help you filter out events.
-We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/data-model/event-payloads/).
+We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/).
## Filtering Error Events
diff --git a/docs/platforms/elixir/enriching-events/breadcrumbs/index.mdx b/docs/platforms/elixir/enriching-events/breadcrumbs/index.mdx
index 8af656caaa6a4..76c5d9e1a4c69 100644
--- a/docs/platforms/elixir/enriching-events/breadcrumbs/index.mdx
+++ b/docs/platforms/elixir/enriching-events/breadcrumbs/index.mdx
@@ -9,7 +9,7 @@ This page provides an overview of manual breadcrumb recording and customization.
-Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/data-model/event-payloads/breadcrumbs/).
+Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/breadcrumbs/).
diff --git a/docs/platforms/elixir/enriching-events/context/index.mdx b/docs/platforms/elixir/enriching-events/context/index.mdx
index 58466e0238a1e..11a3ae0b8afed 100644
--- a/docs/platforms/elixir/enriching-events/context/index.mdx
+++ b/docs/platforms/elixir/enriching-events/context/index.mdx
@@ -23,7 +23,7 @@ Then, use and give the context a
There are no restrictions on context name. In the context object, all keys are allowed except for `type`, which is used internally.
-Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/data-model/event-payloads/contexts/).
+Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/contexts/).
## Size Limitations
diff --git a/docs/platforms/go/common/configuration/filtering.mdx b/docs/platforms/go/common/configuration/filtering.mdx
index a5bf49e5e9f0b..0d307c0630484 100644
--- a/docs/platforms/go/common/configuration/filtering.mdx
+++ b/docs/platforms/go/common/configuration/filtering.mdx
@@ -8,7 +8,7 @@ When you add Sentry to your app, you get a lot of valuable information about err
The Sentry SDKs have several configuration options to help you filter out events.
-We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/data-model/event-payloads/).
+We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/).
## Filtering Error Events
diff --git a/docs/platforms/go/common/enriching-events/breadcrumbs/index.mdx b/docs/platforms/go/common/enriching-events/breadcrumbs/index.mdx
index b0548bf2edb10..108e6e3ad4272 100644
--- a/docs/platforms/go/common/enriching-events/breadcrumbs/index.mdx
+++ b/docs/platforms/go/common/enriching-events/breadcrumbs/index.mdx
@@ -11,7 +11,7 @@ This page provides an overview of manual breadcrumb recording and customization.
-Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/data-model/event-payloads/breadcrumbs/).
+Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/breadcrumbs/).
diff --git a/docs/platforms/go/common/enriching-events/context/index.mdx b/docs/platforms/go/common/enriching-events/context/index.mdx
index e71058c2634d2..7b1f59ac5fda8 100644
--- a/docs/platforms/go/common/enriching-events/context/index.mdx
+++ b/docs/platforms/go/common/enriching-events/context/index.mdx
@@ -23,7 +23,7 @@ Then, use and give the context a uniqu
There are no restrictions on context name. In the context object, all keys are allowed except for `type`, which is used internally.
-Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/data-model/event-payloads/contexts/).
+Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/contexts/).
## Size Limitations
diff --git a/docs/platforms/godot/configuration/filtering.mdx b/docs/platforms/godot/configuration/filtering.mdx
index d97ca31054711..c4962c19dba8e 100644
--- a/docs/platforms/godot/configuration/filtering.mdx
+++ b/docs/platforms/godot/configuration/filtering.mdx
@@ -8,7 +8,7 @@ When you add Sentry to your app, you get a lot of valuable information about err
The Sentry SDKs have several configuration options to help you filter out events.
-We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/data-model/event-payloads/).
+We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/).
## Filtering Error Events
diff --git a/docs/platforms/godot/enriching-events/breadcrumbs/index.mdx b/docs/platforms/godot/enriching-events/breadcrumbs/index.mdx
index 3c8c9791569a6..fd7b975999895 100644
--- a/docs/platforms/godot/enriching-events/breadcrumbs/index.mdx
+++ b/docs/platforms/godot/enriching-events/breadcrumbs/index.mdx
@@ -11,7 +11,7 @@ This page provides an overview of manual breadcrumb recording and customization.
-Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/data-model/event-payloads/breadcrumbs/).
+Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/breadcrumbs/).
diff --git a/docs/platforms/godot/enriching-events/context/index.mdx b/docs/platforms/godot/enriching-events/context/index.mdx
index 472e99c3a3e2c..0cb4293266c83 100644
--- a/docs/platforms/godot/enriching-events/context/index.mdx
+++ b/docs/platforms/godot/enriching-events/context/index.mdx
@@ -23,7 +23,7 @@ Then, use and give the context a uniqu
There are no restrictions on context name. In the context object, all keys are allowed except for `type`, which is used internally.
-Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/data-model/event-payloads/contexts/).
+Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/contexts/).
## Size Limitations
diff --git a/docs/platforms/java/common/configuration/filtering.mdx b/docs/platforms/java/common/configuration/filtering.mdx
index 841289a570f78..46dc39a8429bd 100644
--- a/docs/platforms/java/common/configuration/filtering.mdx
+++ b/docs/platforms/java/common/configuration/filtering.mdx
@@ -8,7 +8,7 @@ When you add Sentry to your app, you get a lot of valuable information about err
The Sentry SDKs have several configuration options to help you filter out events.
-We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/data-model/event-payloads/).
+We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/).
## Filtering Error Events
diff --git a/docs/platforms/java/common/enriching-events/breadcrumbs/index.mdx b/docs/platforms/java/common/enriching-events/breadcrumbs/index.mdx
index b0548bf2edb10..108e6e3ad4272 100644
--- a/docs/platforms/java/common/enriching-events/breadcrumbs/index.mdx
+++ b/docs/platforms/java/common/enriching-events/breadcrumbs/index.mdx
@@ -11,7 +11,7 @@ This page provides an overview of manual breadcrumb recording and customization.
-Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/data-model/event-payloads/breadcrumbs/).
+Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/breadcrumbs/).
diff --git a/docs/platforms/java/common/enriching-events/context/index.mdx b/docs/platforms/java/common/enriching-events/context/index.mdx
index e71058c2634d2..7b1f59ac5fda8 100644
--- a/docs/platforms/java/common/enriching-events/context/index.mdx
+++ b/docs/platforms/java/common/enriching-events/context/index.mdx
@@ -23,7 +23,7 @@ Then, use and give the context a uniqu
There are no restrictions on context name. In the context object, all keys are allowed except for `type`, which is used internally.
-Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/data-model/event-payloads/contexts/).
+Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/contexts/).
## Size Limitations
diff --git a/docs/platforms/javascript/common/configuration/apis.mdx b/docs/platforms/javascript/common/configuration/apis.mdx
index 99e96fea44833..82018197b0734 100644
--- a/docs/platforms/javascript/common/configuration/apis.mdx
+++ b/docs/platforms/javascript/common/configuration/apis.mdx
@@ -340,7 +340,7 @@ By default, Sentry SDKs normalize nested structured context data up to three lev
Any data beyond this depth will be trimmed and marked using its type instead.
To adjust this default, use the `normalizeDepth` SDK option.
-Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/data-model/event-payloads/contexts/).
+Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/contexts/).
Context data is structured and can contain any data you want:
diff --git a/docs/platforms/javascript/common/configuration/filtering.mdx b/docs/platforms/javascript/common/configuration/filtering.mdx
index 877c86348ce5b..1ab69dbd6027b 100644
--- a/docs/platforms/javascript/common/configuration/filtering.mdx
+++ b/docs/platforms/javascript/common/configuration/filtering.mdx
@@ -8,7 +8,7 @@ When you add Sentry to your app, you get a lot of valuable information about err
Sentry offers [Inbound Filters](/concepts/data-management/filtering/) that you can enable per project to filter out various events in sentry.io. You can use our pre-defined inbound filters (e.g. filtering known browser extensions), as well as add your own message-based filters.
-However, we recommend filtering at the client-level, because it removes the overhead of sending events you don't actually want. The [Sentry SDKs](/platforms/) have several configuration options, which are described in this document, to help you filter out events. To learn more about the event fields you can use for filtering, see [Event Payloads](https://develop.sentry.dev/sdk/data-model/event-payloads/).
+However, we recommend filtering at the client-level, because it removes the overhead of sending events you don't actually want. The [Sentry SDKs](/platforms/) have several configuration options, which are described in this document, to help you filter out events. To learn more about the event fields you can use for filtering, see [Event Payloads](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/).
## Filtering Error Events
diff --git a/docs/platforms/javascript/common/enriching-events/breadcrumbs/index.mdx b/docs/platforms/javascript/common/enriching-events/breadcrumbs/index.mdx
index 60ab450c8ac1e..885694bbb1f59 100644
--- a/docs/platforms/javascript/common/enriching-events/breadcrumbs/index.mdx
+++ b/docs/platforms/javascript/common/enriching-events/breadcrumbs/index.mdx
@@ -11,7 +11,7 @@ This page provides an overview of manual breadcrumb recording and customization.
-Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/data-model/event-payloads/breadcrumbs/).
+Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/breadcrumbs/).
diff --git a/docs/platforms/javascript/common/troubleshooting/index.mdx b/docs/platforms/javascript/common/troubleshooting/index.mdx
index 281cab065eb8e..9573aaf353e47 100644
--- a/docs/platforms/javascript/common/troubleshooting/index.mdx
+++ b/docs/platforms/javascript/common/troubleshooting/index.mdx
@@ -52,7 +52,7 @@ You can view the JSON payload of an event to see how Sentry stores additional da
-For more details, see the [full documentation on Event Payload](https://develop.sentry.dev/sdk/data-model/event-payloads/).
+For more details, see the [full documentation on Event Payload](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/).
diff --git a/docs/platforms/kotlin/guides/kotlin-multiplatform/configuration/filtering.mdx b/docs/platforms/kotlin/guides/kotlin-multiplatform/configuration/filtering.mdx
index d97ca31054711..c4962c19dba8e 100644
--- a/docs/platforms/kotlin/guides/kotlin-multiplatform/configuration/filtering.mdx
+++ b/docs/platforms/kotlin/guides/kotlin-multiplatform/configuration/filtering.mdx
@@ -8,7 +8,7 @@ When you add Sentry to your app, you get a lot of valuable information about err
The Sentry SDKs have several configuration options to help you filter out events.
-We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/data-model/event-payloads/).
+We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/).
## Filtering Error Events
diff --git a/docs/platforms/kotlin/guides/kotlin-multiplatform/enriching-events/breadcrumbs/index.mdx b/docs/platforms/kotlin/guides/kotlin-multiplatform/enriching-events/breadcrumbs/index.mdx
index 0fce666395cab..61aa5c9768906 100644
--- a/docs/platforms/kotlin/guides/kotlin-multiplatform/enriching-events/breadcrumbs/index.mdx
+++ b/docs/platforms/kotlin/guides/kotlin-multiplatform/enriching-events/breadcrumbs/index.mdx
@@ -9,7 +9,7 @@ This page provides an overview of manual breadcrumb recording and customization.
-Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/data-model/event-payloads/breadcrumbs/).
+Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/breadcrumbs/).
diff --git a/docs/platforms/kotlin/guides/kotlin-multiplatform/enriching-events/context/index.mdx b/docs/platforms/kotlin/guides/kotlin-multiplatform/enriching-events/context/index.mdx
index e71058c2634d2..7b1f59ac5fda8 100644
--- a/docs/platforms/kotlin/guides/kotlin-multiplatform/enriching-events/context/index.mdx
+++ b/docs/platforms/kotlin/guides/kotlin-multiplatform/enriching-events/context/index.mdx
@@ -23,7 +23,7 @@ Then, use and give the context a uniqu
There are no restrictions on context name. In the context object, all keys are allowed except for `type`, which is used internally.
-Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/data-model/event-payloads/contexts/).
+Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/contexts/).
## Size Limitations
diff --git a/docs/platforms/native/common/configuration/filtering.mdx b/docs/platforms/native/common/configuration/filtering.mdx
index 46e7aaf2db073..261a28dd8abf4 100644
--- a/docs/platforms/native/common/configuration/filtering.mdx
+++ b/docs/platforms/native/common/configuration/filtering.mdx
@@ -8,7 +8,7 @@ When you add Sentry to your app, you get a lot of valuable information about err
The Sentry SDKs have several configuration options to help you filter out events.
-We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/data-model/event-payloads/).
+We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/).
## Filtering Error Events
diff --git a/docs/platforms/native/common/enriching-events/breadcrumbs/index.mdx b/docs/platforms/native/common/enriching-events/breadcrumbs/index.mdx
index 01f0427a8fa47..57324bb9bba6d 100644
--- a/docs/platforms/native/common/enriching-events/breadcrumbs/index.mdx
+++ b/docs/platforms/native/common/enriching-events/breadcrumbs/index.mdx
@@ -16,7 +16,7 @@ This page provides an overview of manual breadcrumb recording and customization.
-Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/data-model/event-payloads/breadcrumbs/).
+Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/breadcrumbs/).
diff --git a/docs/platforms/native/common/enriching-events/context/index.mdx b/docs/platforms/native/common/enriching-events/context/index.mdx
index 4f1ffe56cf761..ff16531137c60 100644
--- a/docs/platforms/native/common/enriching-events/context/index.mdx
+++ b/docs/platforms/native/common/enriching-events/context/index.mdx
@@ -28,7 +28,7 @@ Then, use and give the context a uniqu
There are no restrictions on context name. In the context object, all keys are allowed except for `type`, which is used internally.
-Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/data-model/event-payloads/contexts/).
+Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/contexts/).
## Size Limitations
diff --git a/docs/platforms/native/guides/minidumps/index.mdx b/docs/platforms/native/guides/minidumps/index.mdx
index 2d96407dda846..a49d59487042b 100644
--- a/docs/platforms/native/guides/minidumps/index.mdx
+++ b/docs/platforms/native/guides/minidumps/index.mdx
@@ -41,7 +41,7 @@ they might contain sensitive information on the target system, such as
environment variables, local pathnames or maybe even in-memory representations
of input fields, including passwords. **Sentry does not store these memory
dumps by default**. Once processed, they are removed immediately, and all sensitive
-information is stripped from the resulting issues.
+information is stripped from the resulting issues.
You can configure Sentry to store the minidump as attachment.
@@ -109,7 +109,7 @@ curl -X POST \
-F 'sentry[tags][mytag]=value'
```
-For the full list of supported values, see [_Event Payloads_](https://develop.sentry.dev/sdk/data-model/event-payloads/) and linked
+For the full list of supported values, see [_Event Payloads_](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/) and linked
documents.
If your minidump's size exceeds the [limits](#size-limits) in the next section, you can compress it using `gzip`, `zstd`, `bzip2` or `xz` and refer the `upload_file_minidump` to the compressed file instead of the plain minidump.
diff --git a/docs/platforms/native/guides/wasm/index.mdx b/docs/platforms/native/guides/wasm/index.mdx
index 9ec44b87158d4..64bc149ff84eb 100644
--- a/docs/platforms/native/guides/wasm/index.mdx
+++ b/docs/platforms/native/guides/wasm/index.mdx
@@ -56,7 +56,7 @@ This is [documented in detail](/platforms/javascript/guides/wasm/) in the JavaSc
It's likely that if you're working with WebAssembly, you want to send custom
crash reports; for example, if you don't execute WebAssembly in a browser, but in your
own runtime. In that case, you can follow the general protocol documentation which
-also covers how to describe WebAssembly frames: [stack trace interface](https://develop.sentry.dev/sdk/data-model/event-payloads/stacktrace/).
+also covers how to describe WebAssembly frames: [stack trace interface](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/stacktrace/).
Here is an example event for WebAssembly:
diff --git a/docs/platforms/php/common/configuration/filtering.mdx b/docs/platforms/php/common/configuration/filtering.mdx
index da0c40d850b1d..fd949528146c4 100644
--- a/docs/platforms/php/common/configuration/filtering.mdx
+++ b/docs/platforms/php/common/configuration/filtering.mdx
@@ -8,7 +8,7 @@ When you add Sentry to your app, you get a lot of valuable information about err
The Sentry SDKs have several configuration options to help you filter out events.
-We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/data-model/event-payloads/).
+We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/).
## Filtering Error Events
diff --git a/docs/platforms/php/common/enriching-events/breadcrumbs/index.mdx b/docs/platforms/php/common/enriching-events/breadcrumbs/index.mdx
index 15ca7976802b9..d93a015d7281e 100644
--- a/docs/platforms/php/common/enriching-events/breadcrumbs/index.mdx
+++ b/docs/platforms/php/common/enriching-events/breadcrumbs/index.mdx
@@ -11,7 +11,7 @@ This page provides an overview of manual breadcrumb recording and customization.
-Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/data-model/event-payloads/breadcrumbs/).
+Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/breadcrumbs/).
diff --git a/docs/platforms/php/common/enriching-events/context/index.mdx b/docs/platforms/php/common/enriching-events/context/index.mdx
index e71058c2634d2..7b1f59ac5fda8 100644
--- a/docs/platforms/php/common/enriching-events/context/index.mdx
+++ b/docs/platforms/php/common/enriching-events/context/index.mdx
@@ -23,7 +23,7 @@ Then, use and give the context a uniqu
There are no restrictions on context name. In the context object, all keys are allowed except for `type`, which is used internally.
-Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/data-model/event-payloads/contexts/).
+Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/contexts/).
## Size Limitations
diff --git a/docs/platforms/powershell/configuration/filtering.mdx b/docs/platforms/powershell/configuration/filtering.mdx
index 5f7e82455996e..761b809af644d 100644
--- a/docs/platforms/powershell/configuration/filtering.mdx
+++ b/docs/platforms/powershell/configuration/filtering.mdx
@@ -8,7 +8,7 @@ When you add Sentry to your app, you get a lot of valuable information about err
The Sentry SDKs have several configuration options to help you filter out events.
-We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/data-model/event-payloads/).
+We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/).
## Filtering Error Events
diff --git a/docs/platforms/powershell/enriching-events/breadcrumbs/index.mdx b/docs/platforms/powershell/enriching-events/breadcrumbs/index.mdx
index c780b4de862d2..8cc015a75288b 100644
--- a/docs/platforms/powershell/enriching-events/breadcrumbs/index.mdx
+++ b/docs/platforms/powershell/enriching-events/breadcrumbs/index.mdx
@@ -9,7 +9,7 @@ This page provides an overview of manual breadcrumb recording and customization.
-Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/data-model/event-payloads/breadcrumbs/).
+Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/breadcrumbs/).
diff --git a/docs/platforms/powershell/enriching-events/context/index.mdx b/docs/platforms/powershell/enriching-events/context/index.mdx
index 3c36bc77e1f8b..34e651925945d 100644
--- a/docs/platforms/powershell/enriching-events/context/index.mdx
+++ b/docs/platforms/powershell/enriching-events/context/index.mdx
@@ -23,7 +23,7 @@ Then, use `Contexts` and give the context a unique name:
There are no restrictions on context name. In the context object, all keys are allowed except for `type`, which is used internally.
-Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/data-model/event-payloads/contexts/).
+Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/contexts/).
## Size Limitations
diff --git a/docs/platforms/python/configuration/filtering/index.mdx b/docs/platforms/python/configuration/filtering/index.mdx
index c3865d08a9501..d1b4a60ef33ac 100644
--- a/docs/platforms/python/configuration/filtering/index.mdx
+++ b/docs/platforms/python/configuration/filtering/index.mdx
@@ -8,7 +8,7 @@ When you add Sentry to your app, you get a lot of valuable information about err
The Sentry SDKs have several configuration options to help you filter out events.
-We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/data-model/event-payloads/).
+We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/).
## Filtering Error Events
diff --git a/docs/platforms/python/enriching-events/breadcrumbs/index.mdx b/docs/platforms/python/enriching-events/breadcrumbs/index.mdx
index 3c9cfba72bcf5..c9e14ff4df44a 100644
--- a/docs/platforms/python/enriching-events/breadcrumbs/index.mdx
+++ b/docs/platforms/python/enriching-events/breadcrumbs/index.mdx
@@ -11,7 +11,7 @@ This page provides an overview of manual breadcrumb recording and customization.
-Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/data-model/event-payloads/breadcrumbs/).
+Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/breadcrumbs/).
diff --git a/docs/platforms/python/enriching-events/context/index.mdx b/docs/platforms/python/enriching-events/context/index.mdx
index e71058c2634d2..7b1f59ac5fda8 100644
--- a/docs/platforms/python/enriching-events/context/index.mdx
+++ b/docs/platforms/python/enriching-events/context/index.mdx
@@ -23,7 +23,7 @@ Then, use and give the context a uniqu
There are no restrictions on context name. In the context object, all keys are allowed except for `type`, which is used internally.
-Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/data-model/event-payloads/contexts/).
+Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/contexts/).
## Size Limitations
diff --git a/docs/platforms/python/integrations/cloudresourcecontext/index.mdx b/docs/platforms/python/integrations/cloudresourcecontext/index.mdx
index 578a8bead6fca..482adc5c297a3 100644
--- a/docs/platforms/python/integrations/cloudresourcecontext/index.mdx
+++ b/docs/platforms/python/integrations/cloudresourcecontext/index.mdx
@@ -71,7 +71,7 @@ Trigger an error in the code running in your cloud and see the error and perform
## Behavior
When the SDK starts up, information from the cloud provider the app is running in is retrieved and added to all error and performance events sent to Sentry.
-The [developer documentation](https://develop.sentry.dev/sdk/data-model/event-payloads/contexts/#runtime-context) lists all the information that's being added.
+The [developer documentation](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/contexts/#runtime-context) lists all the information that's being added.
In AWS EC2 the context looks like this:
diff --git a/docs/platforms/python/legacy-sdk/breadcrumbs.mdx b/docs/platforms/python/legacy-sdk/breadcrumbs.mdx
index a9e91b7092345..ca8813934364b 100644
--- a/docs/platforms/python/legacy-sdk/breadcrumbs.mdx
+++ b/docs/platforms/python/legacy-sdk/breadcrumbs.mdx
@@ -71,7 +71,7 @@ If you want to manually record breadcrumbs the most convenient way to do that is
`raven.breadcrumbs.record(**options)`
-This function accepts keyword arguments matching the attributes of a breadcrumb. For more information see [_Event Payloads_](https://develop.sentry.dev/sdk/data-model/event-payloads/). Additionally, a _processor_ callback can be passed which will be invoked to process the data if the crumb was not rejected.
+This function accepts keyword arguments matching the attributes of a breadcrumb. For more information see [_Event Payloads_](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/). Additionally, a _processor_ callback can be passed which will be invoked to process the data if the crumb was not rejected.
The most important parameters:
diff --git a/docs/platforms/react-native/configuration/filtering.mdx b/docs/platforms/react-native/configuration/filtering.mdx
index 93da17209a75b..a89240ee6afda 100644
--- a/docs/platforms/react-native/configuration/filtering.mdx
+++ b/docs/platforms/react-native/configuration/filtering.mdx
@@ -8,7 +8,7 @@ When you add Sentry to your app, you get a lot of valuable information about err
The Sentry SDKs have several configuration options to help you filter out events.
-We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/data-model/event-payloads/).
+We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/).
## Filtering Error Events
@@ -20,7 +20,7 @@ All Sentry SDKs support the callback m
-The beforeSend callback in the React Native SDK only filters events generated from the JavaScript layer. Native events (from Android, iOS, or other native code) are not filtered.
+The beforeSend callback in the React Native SDK only filters events generated from the JavaScript layer. Native events (from Android, iOS, or other native code) are not filtered.
Note also that breadcrumbs can be filtered, as discussed in [our Breadcrumbs documentation](/product/error-monitoring/breadcrumbs/).
diff --git a/docs/platforms/react-native/enriching-events/breadcrumbs/index.mdx b/docs/platforms/react-native/enriching-events/breadcrumbs/index.mdx
index 3027c2b0bf7db..4000058a99bc8 100644
--- a/docs/platforms/react-native/enriching-events/breadcrumbs/index.mdx
+++ b/docs/platforms/react-native/enriching-events/breadcrumbs/index.mdx
@@ -11,7 +11,7 @@ This page provides an overview of manual breadcrumb recording and customization.
-Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/data-model/event-payloads/breadcrumbs/).
+Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/breadcrumbs/).
diff --git a/docs/platforms/react-native/enriching-events/context/index.mdx b/docs/platforms/react-native/enriching-events/context/index.mdx
index c89cf5697bf25..927e72a2e4deb 100644
--- a/docs/platforms/react-native/enriching-events/context/index.mdx
+++ b/docs/platforms/react-native/enriching-events/context/index.mdx
@@ -29,7 +29,7 @@ There are no restrictions on context name. In the context object, all keys are a
By default, Sentry SDKs normalize nested structured context data up to three levels deep. Any data beyond this depth will be trimmed and marked using its type instead. To adjust this default, use the `normalizeDepth` SDK option.
-Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/data-model/event-payloads/contexts/).
+Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/contexts/).
## Size Limitations
diff --git a/docs/platforms/ruby/common/configuration/filtering.mdx b/docs/platforms/ruby/common/configuration/filtering.mdx
index ce39ee8928a0a..f0975785e5719 100644
--- a/docs/platforms/ruby/common/configuration/filtering.mdx
+++ b/docs/platforms/ruby/common/configuration/filtering.mdx
@@ -9,7 +9,7 @@ When you add Sentry to your app, you get a lot of valuable information about err
The Sentry SDKs have several configuration options to help you filter out events.
-We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/data-model/event-payloads/).
+We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/).
## Filtering Error Events
diff --git a/docs/platforms/ruby/common/enriching-events/breadcrumbs/index.mdx b/docs/platforms/ruby/common/enriching-events/breadcrumbs/index.mdx
index 17d6f87b0812a..6799f986ea9bc 100644
--- a/docs/platforms/ruby/common/enriching-events/breadcrumbs/index.mdx
+++ b/docs/platforms/ruby/common/enriching-events/breadcrumbs/index.mdx
@@ -11,7 +11,7 @@ This page provides an overview of manual breadcrumb recording and customization.
-Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/data-model/event-payloads/breadcrumbs/).
+Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/breadcrumbs/).
diff --git a/docs/platforms/ruby/common/enriching-events/context/index.mdx b/docs/platforms/ruby/common/enriching-events/context/index.mdx
index e71058c2634d2..7b1f59ac5fda8 100644
--- a/docs/platforms/ruby/common/enriching-events/context/index.mdx
+++ b/docs/platforms/ruby/common/enriching-events/context/index.mdx
@@ -23,7 +23,7 @@ Then, use and give the context a uniqu
There are no restrictions on context name. In the context object, all keys are allowed except for `type`, which is used internally.
-Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/data-model/event-payloads/contexts/).
+Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/contexts/).
## Size Limitations
diff --git a/docs/platforms/rust/common/configuration/filtering.mdx b/docs/platforms/rust/common/configuration/filtering.mdx
index e466dfedce1df..7825915a82785 100644
--- a/docs/platforms/rust/common/configuration/filtering.mdx
+++ b/docs/platforms/rust/common/configuration/filtering.mdx
@@ -8,7 +8,7 @@ When you add Sentry to your app, you get a lot of valuable information about err
The Sentry SDKs have several configuration options to help you filter out events.
-We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/data-model/event-payloads/).
+We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/).
## Filtering Error Events
diff --git a/docs/platforms/rust/common/enriching-events/breadcrumbs/index.mdx b/docs/platforms/rust/common/enriching-events/breadcrumbs/index.mdx
index 37152cc309740..f333a3b01c923 100644
--- a/docs/platforms/rust/common/enriching-events/breadcrumbs/index.mdx
+++ b/docs/platforms/rust/common/enriching-events/breadcrumbs/index.mdx
@@ -11,7 +11,7 @@ This page provides an overview of manual breadcrumb recording and customization.
-Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/data-model/event-payloads/breadcrumbs/).
+Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/breadcrumbs/).
diff --git a/docs/platforms/rust/common/enriching-events/context/index.mdx b/docs/platforms/rust/common/enriching-events/context/index.mdx
index e71058c2634d2..7b1f59ac5fda8 100644
--- a/docs/platforms/rust/common/enriching-events/context/index.mdx
+++ b/docs/platforms/rust/common/enriching-events/context/index.mdx
@@ -23,7 +23,7 @@ Then, use and give the context a uniqu
There are no restrictions on context name. In the context object, all keys are allowed except for `type`, which is used internally.
-Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/data-model/event-payloads/contexts/).
+Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/contexts/).
## Size Limitations
diff --git a/docs/platforms/unity/configuration/filtering.mdx b/docs/platforms/unity/configuration/filtering.mdx
index a192c3c5e5a86..17df7ebc658d1 100644
--- a/docs/platforms/unity/configuration/filtering.mdx
+++ b/docs/platforms/unity/configuration/filtering.mdx
@@ -8,7 +8,7 @@ When you add Sentry to your app, you get a lot of valuable information about err
The Sentry SDKs have several configuration options to help you filter out events.
-We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/data-model/event-payloads/).
+We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/).
## Filtering Error Events
diff --git a/docs/platforms/unity/enriching-events/breadcrumbs/index.mdx b/docs/platforms/unity/enriching-events/breadcrumbs/index.mdx
index 909b014f6d0e8..0df528d7ac839 100644
--- a/docs/platforms/unity/enriching-events/breadcrumbs/index.mdx
+++ b/docs/platforms/unity/enriching-events/breadcrumbs/index.mdx
@@ -9,7 +9,7 @@ This page provides an overview of manual breadcrumb recording and customization.
-Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/data-model/event-payloads/breadcrumbs/).
+Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/breadcrumbs/).
diff --git a/docs/platforms/unity/enriching-events/context/index.mdx b/docs/platforms/unity/enriching-events/context/index.mdx
index 50397edad32d7..3f2629fc7a059 100644
--- a/docs/platforms/unity/enriching-events/context/index.mdx
+++ b/docs/platforms/unity/enriching-events/context/index.mdx
@@ -29,7 +29,7 @@ The class must be serializable and only properties are included; fields are not.
There are no restrictions on context name. In the context object, all keys are allowed except for `type`, which is used internally.
-Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/data-model/event-payloads/contexts/).
+Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/contexts/).
## Size Limitations
diff --git a/docs/platforms/unreal/configuration/filtering.mdx b/docs/platforms/unreal/configuration/filtering.mdx
index d97ca31054711..c4962c19dba8e 100644
--- a/docs/platforms/unreal/configuration/filtering.mdx
+++ b/docs/platforms/unreal/configuration/filtering.mdx
@@ -8,7 +8,7 @@ When you add Sentry to your app, you get a lot of valuable information about err
The Sentry SDKs have several configuration options to help you filter out events.
-We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/data-model/event-payloads/).
+We also offer [Inbound Filters](/concepts/data-management/filtering/) to filter events in sentry.io. We recommend filtering at the client level though, because it removes the overhead of sending events you don't actually want. Learn more about the [fields available in an event](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/).
## Filtering Error Events
diff --git a/docs/platforms/unreal/configuration/setup-crashreporter/index.mdx b/docs/platforms/unreal/configuration/setup-crashreporter/index.mdx
index f74c0ac1bff94..8e2483b96cc9b 100644
--- a/docs/platforms/unreal/configuration/setup-crashreporter/index.mdx
+++ b/docs/platforms/unreal/configuration/setup-crashreporter/index.mdx
@@ -150,7 +150,7 @@ void ConfigureCrashReporter()
```
You need to call the `ConfigureCrashReporter` some time after your game
-starts. Any [event attribute](https://develop.sentry.dev/sdk/data-model/event-payloads/) can be set.
+starts. Any [event attribute](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/) can be set.
diff --git a/docs/platforms/unreal/enriching-events/breadcrumbs/index.mdx b/docs/platforms/unreal/enriching-events/breadcrumbs/index.mdx
index 0bd7ec5ae8b06..38449b24258e5 100644
--- a/docs/platforms/unreal/enriching-events/breadcrumbs/index.mdx
+++ b/docs/platforms/unreal/enriching-events/breadcrumbs/index.mdx
@@ -14,7 +14,7 @@ This page provides an overview of manual breadcrumb recording and customization.
-Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/data-model/event-payloads/breadcrumbs/).
+Developers who want to modify the breadcrumbs interface can learn more in our [developer documentation about the Breadcrumbs Interface](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/breadcrumbs/).
diff --git a/docs/platforms/unreal/enriching-events/context/index.mdx b/docs/platforms/unreal/enriching-events/context/index.mdx
index 046d19092e9e4..6d17cec7019b4 100644
--- a/docs/platforms/unreal/enriching-events/context/index.mdx
+++ b/docs/platforms/unreal/enriching-events/context/index.mdx
@@ -46,7 +46,7 @@ Sentry's SDK automatically attaches certain context values such as `Engine versi
There are no restrictions on context name. In the context object, all keys are allowed except for `type`, which is used internally.
-Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/data-model/event-payloads/contexts/).
+Learn more about conventions for common contexts in the [contexts interface developer documentation](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/contexts/).
## Size Limitations
diff --git a/docs/product/insights/overview/metrics.mdx b/docs/product/insights/overview/metrics.mdx
index c239f534afb7d..9159378386a05 100644
--- a/docs/product/insights/overview/metrics.mdx
+++ b/docs/product/insights/overview/metrics.mdx
@@ -26,7 +26,7 @@ Configure what a satisfactory response time threshold (ms) is for Apdex in **Set
## Failure Rate
-`failure_rate()` indicates the percentage of unsuccessful transactions. Sentry treats transactions with a status other than “ok,” “cancelled,” and “unknown” as failures. For more details, see a [list of possible status values](https://develop.sentry.dev/sdk/data-model/event-payloads/span/).
+`failure_rate()` indicates the percentage of unsuccessful transactions. Sentry treats transactions with a status other than “ok,” “cancelled,” and “unknown” as failures. For more details, see a [list of possible status values](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/span/).
## Throughput (Total, TPM, TPS)
diff --git a/docs/product/issues/issue-details/breadcrumbs/index.mdx b/docs/product/issues/issue-details/breadcrumbs/index.mdx
index 28bfae414d719..38b84cd771a96 100644
--- a/docs/product/issues/issue-details/breadcrumbs/index.mdx
+++ b/docs/product/issues/issue-details/breadcrumbs/index.mdx
@@ -36,7 +36,7 @@ Here are all the ways you can narrow down what you see:
Each breadcrumb is composed of the following:
-- **Type**: `type` is a semi-internal attribute that controls how breadcrumbs are categorized. If left unchanged, all breadcrumbs are recorded as `default`, but Sentry provides other [types](https://develop.sentry.dev/sdk/data-model/event-payloads/breadcrumbs/#breadcrumb-types) that each have their own color/icon in the UI.
+- **Type**: `type` is a semi-internal attribute that controls how breadcrumbs are categorized. If left unchanged, all breadcrumbs are recorded as `default`, but Sentry provides other [types](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/breadcrumbs/#breadcrumb-types) that each have their own color/icon in the UI.
- **Category**: The event category. This data is similar to a logger name and helps you understand where an event took place, such as `auth`.
@@ -49,4 +49,4 @@ Each breadcrumb is composed of the following:
- **Time**: A timestamp showing when the breadcrumb occurred. The format is either a string, as defined in [RFC 3339](https://tools.ietf.org/html/rfc3339), or a numeric value representing the number of seconds that have elapsed since the Unix epoch.
-Learn more detailed information about breadcrumb data in the [Breadcrumbs Interface developer documentation](https://develop.sentry.dev/sdk/data-model/event-payloads/breadcrumbs/).
+Learn more detailed information about breadcrumb data in the [Breadcrumbs Interface developer documentation](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/breadcrumbs/).
diff --git a/platform-includes/capture-message/native.mdx b/platform-includes/capture-message/native.mdx
index b09c560aa43a5..1318b7e80d7de 100644
--- a/platform-includes/capture-message/native.mdx
+++ b/platform-includes/capture-message/native.mdx
@@ -37,4 +37,4 @@ sentry_value_set_by_key(event, "contexts", contexts);
sentry_capture_event(event);
```
-For the full list of supported values, see [_Event Payloads_](https://develop.sentry.dev/sdk/data-model/event-payloads/) and linked documents.
+For the full list of supported values, see [_Event Payloads_](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/) and linked documents.
diff --git a/platform-includes/capture-message/unreal.mdx b/platform-includes/capture-message/unreal.mdx
index 9295565c2d811..cd6ac664ffcc1 100644
--- a/platform-includes/capture-message/unreal.mdx
+++ b/platform-includes/capture-message/unreal.mdx
@@ -88,4 +88,4 @@ Scoped events capturing is supported only on macOS, iOS and Android platforms.
-For the full list of supported values, check out [_Event Payloads_](https://develop.sentry.dev/sdk/data-model/event-payloads/) and linked documents.
+For the full list of supported values, check out [_Event Payloads_](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/) and linked documents.
diff --git a/platform-includes/enriching-events/breadcrumbs/automatic-breadcrumbs/dart.mdx b/platform-includes/enriching-events/breadcrumbs/automatic-breadcrumbs/dart.mdx
index 17efd502ca499..3219f037d6e9e 100644
--- a/platform-includes/enriching-events/breadcrumbs/automatic-breadcrumbs/dart.mdx
+++ b/platform-includes/enriching-events/breadcrumbs/automatic-breadcrumbs/dart.mdx
@@ -1,4 +1,4 @@
-To track automatic [Breadcrumbs for HTTP requests](https://develop.sentry.dev/sdk/data-model/event-payloads/breadcrumbs/#breadcrumb-types), you can add a Sentry wrapper that does it automatically for you.
+To track automatic [Breadcrumbs for HTTP requests](https://develop.sentry.dev/sdk/foundations/data-model/event-payloads/breadcrumbs/#breadcrumb-types), you can add a Sentry wrapper that does it automatically for you.
The following code applies if you are using the [http.Client](https://pub.dev/documentation/http/latest/http/Client-class.html) class from the [http](https://pub.dev/packages/http) library.
If you're using package `Dio`, please refer to our [`sentry_dio`](https://pub.dev/packages/sentry_dio) integration.
diff --git a/redirects.js b/redirects.js
index 3625635638a91..addc67726e466 100644
--- a/redirects.js
+++ b/redirects.js
@@ -28,7 +28,15 @@ const developerDocsRedirects = [
},
{
source: '/sdk/data-model/event-payloads/types/',
- destination: '/sdk/data-model/event-payloads/',
+ destination: '/sdk/foundations/data-model/event-payloads/',
+ },
+ {
+ source: '/sdk/data-model/event-payloads/',
+ destination: '/sdk/foundations/data-model/event-payloads/',
+ },
+ {
+ source: '/sdk/data-model/event-payloads/:path*',
+ destination: '/sdk/foundations/data-model/event-payloads/:path*',
},
{
source: '/sdk/basics/:path*',
@@ -52,7 +60,7 @@ const developerDocsRedirects = [
},
{
source: '/sdk/event-payloads/:path*',
- destination: '/sdk/data-model/event-payloads/:path*',
+ destination: '/sdk/foundations/data-model/event-payloads/:path*',
},
{
source: '/sdk/hub_and_scope_refactoring/:path*',
@@ -1067,15 +1075,18 @@ const userDocsRedirects = [
destination: '/platforms/javascript/ai-agent-monitoring/:path*',
},
{
- source: '/platforms/javascript/guides/:guide/tracing/instrumentation/ai-agents-module/:path*',
+ source:
+ '/platforms/javascript/guides/:guide/tracing/instrumentation/ai-agents-module/:path*',
destination: '/platforms/javascript/guides/:guide/ai-agent-monitoring/:path*',
},
{
- source: '/platforms/javascript/tracing/instrumentation/ai-agents-module-browser/:path*',
+ source:
+ '/platforms/javascript/tracing/instrumentation/ai-agents-module-browser/:path*',
destination: '/platforms/javascript/ai-agent-monitoring-browser/:path*',
},
{
- source: '/platforms/javascript/guides/:guide/tracing/instrumentation/ai-agents-module-browser/:path*',
+ source:
+ '/platforms/javascript/guides/:guide/tracing/instrumentation/ai-agents-module-browser/:path*',
destination: '/platforms/javascript/guides/:guide/ai-agent-monitoring-browser/',
},
// Browser JS doesn't have server-side AI Agent Monitoring, redirect to browser version
diff --git a/src/middleware.ts b/src/middleware.ts
index 92e345becac1b..16288c7ff2285 100644
--- a/src/middleware.ts
+++ b/src/middleware.ts
@@ -3072,7 +3072,7 @@ const USER_DOCS_REDIRECTS: Redirect[] = [
},
{
from: '/clientdev/interfaces/http/',
- to: 'https://develop.sentry.dev/sdk/data-model/event-payloads/request',
+ to: 'https://develop.sentry.dev/sdk/foundation/data-model/event-payloads/request',
},
{
from: '/clients/csharp/',
@@ -4332,11 +4332,11 @@ const DEVELOPER_DOCS_REDIRECTS: Redirect[] = [
},
{
from: '/sdk/data-model/envelopes/',
- to: '/sdk/foundations/transport/envelopes/',
+ to: '/sdk/foundations/data-model/envelopes/',
},
{
from: '/sdk/data-model/envelope-items/',
- to: '/sdk/foundations/transport/envelope-items/',
+ to: '/sdk/foundations/data-model/envelope-items/',
},
{
from: '/sdk/expected-features/rate-limiting/',
@@ -4346,6 +4346,74 @@ const DEVELOPER_DOCS_REDIRECTS: Redirect[] = [
from: '/sdk/overview/',
to: '/sdk/foundations/overview/',
},
+ {
+ from: '/sdk/data-model/',
+ to: '/sdk/foundations/data-model/',
+ },
+ {
+ from: '/sdk/data-model/event-payloads/',
+ to: '/sdk/foundations/data-model/event-payloads/',
+ },
+ {
+ from: '/sdk/data-model/event-payloads/breadcrumbs/',
+ to: '/sdk/foundations/data-model/event-payloads/breadcrumbs/',
+ },
+ {
+ from: '/sdk/data-model/event-payloads/contexts/',
+ to: '/sdk/foundations/data-model/event-payloads/contexts/',
+ },
+ {
+ from: '/sdk/data-model/event-payloads/debugmeta/',
+ to: '/sdk/foundations/data-model/event-payloads/debugmeta/',
+ },
+ {
+ from: '/sdk/data-model/event-payloads/exception/',
+ to: '/sdk/foundations/data-model/event-payloads/exception/',
+ },
+ {
+ from: '/sdk/data-model/event-payloads/lockreason/',
+ to: '/sdk/foundations/data-model/event-payloads/lockreason/',
+ },
+ {
+ from: '/sdk/data-model/event-payloads/message/',
+ to: '/sdk/foundations/data-model/event-payloads/message/',
+ },
+ {
+ from: '/sdk/data-model/event-payloads/replay-recording/',
+ to: '/sdk/foundations/data-model/event-payloads/replay-recording/',
+ },
+ {
+ from: '/sdk/data-model/event-payloads/request/',
+ to: '/sdk/foundations/data-model/event-payloads/request/',
+ },
+ {
+ from: '/sdk/data-model/event-payloads/sdk/',
+ to: '/sdk/foundations/data-model/event-payloads/sdk/',
+ },
+ {
+ from: '/sdk/data-model/event-payloads/span/',
+ to: '/sdk/foundations/data-model/event-payloads/span/',
+ },
+ {
+ from: '/sdk/data-model/event-payloads/stacktrace/',
+ to: '/sdk/foundations/data-model/event-payloads/stacktrace/',
+ },
+ {
+ from: '/sdk/data-model/event-payloads/template/',
+ to: '/sdk/foundations/data-model/event-payloads/template/',
+ },
+ {
+ from: '/sdk/data-model/event-payloads/threads/',
+ to: '/sdk/foundations/data-model/event-payloads/threads/',
+ },
+ {
+ from: '/sdk/data-model/event-payloads/transaction/',
+ to: '/sdk/foundations/data-model/event-payloads/transaction/',
+ },
+ {
+ from: '/sdk/data-model/event-payloads/user/',
+ to: '/sdk/foundations/data-model/event-payloads/user/',
+ },
];
const redirectMap = new Map(