Merge branch 'master' of github.com:getsentry/sentry-docs into txiao/docs/update-python-continuous-profiling-docs

Author: Zylphrex

develop-docs/sdk/data-model/event-payloads/contexts.mdx

@@ -674,30 +674,6 @@ Additional information that allows Sentry to connect multiple transactions, span
   | `data_loss`                  | Unrecoverable data loss or corruption                                                                        | 500                         |
   | `unauthenticated`            | The requester doesn't have valid authentication credentials for the operation                                | 401                         |
 
-`exclusive_time`
-
-: _Optional_. The amount of time in milliseconds spent in this transaction span, excluding its immediate child spans.
-
-- Example: `1.035`
-
-`client_sample_rate`
-
-: _Optional_. The client-side sample rate.
-
-- Example: `0.1`
-
-`tags`
-
-: _Optional_. A map or list of tags for this event. Each tag must be less than 200 characters.
-
-- Example: `{ "deviceMemory": "8 GB", "effectiveConnectionType": "4g", "routing.instrumentation": "react-router-v3" }`
-
-`dynamic_sampling_context`
-
-: _Optional_. The [Dynamic Sampling Context](/sdk/performance/dynamic-sampling-context/).
-
-- Example: `{ "trace_id": "12312012123120121231201212312012", "sample_rate": "1.0", "public_key": "93D0D1125146288EAEE2A9B3AF4F96CCBE3CB316" },`
-
 `origin`
 
 : _Optional_. The origin of the trace indicates what created the trace. For more details, see [trace origin](/sdk/performance/trace-origin/).
@@ -731,16 +707,6 @@ If the route is set to a string (e.g. `"route": "foo"`), it will be normalized i
       "parent_span_id": null,
       "description": "<OrganizationContext>",
       "op": "http.server",
-      "tags": {
-        "deviceMemory": "8 GB",
-        "effectiveConnectionType": "4g",
-        "routing.instrumentation": "react-router-v3"
-      },
-      "dynamic_sampling_context": {
-        "trace_id": "12312012123120121231201212312012",
-        "sample_rate": "1.0",
-        "public_key": "93D0D1125146288EAEE2A9B3AF4F96CCBE3CB316"
-      },
       "origin": "auto.http.http_client_5",
       "data": {
         "route": {

develop-docs/sdk/telemetry/spans/batch-processor.mdx

@@ -0,0 +1,83 @@
+---
+title: Batch Processor
+---
+
+<Alert level="warning">
+  🚧 This document is work in progress.
+</Alert>
+
+<Alert>
+  This document uses key words such as "MUST", "SHOULD", and "MAY" as defined in [RFC 2119](https://www.ietf.org/rfc/rfc2119.txt) to indicate requirement levels.
+</Alert>
+
+The BatchProcessor batches spans and logs into one envelope to reduce the number of HTTP requests. When an SDK implements span streaming or logs, it MUST use a BatchProcessor, which is similar to [OpenTelemetry's Batch Processor](https://github.com/open-telemetry/opentelemetry-collector/blob/main/processor/batchprocessor/README.md). The BatchProcessor holds logs and finished spans in memory and batches them together into envelopes. It uses a combination of time and size-based batching. When writing this, the BatchProcessor only handles spans and logs, but an SDK MAY use it for other telemetry data in the future.
+
+## Specification
+
+Whenever the SDK finishes a span or captures a log, it MUST put it into the BatchProcessor. The SDK MUST NOT put unfinished spans into the BatchProcessor.
+
+The BatchProcessor MUST start a timeout of 5 seconds when the SDK adds the first span or log. When the timeout exceeds, the BatchProcessor MUST send all spans or logs, 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 MUST send all items 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. The SDK MUST 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 sends all spans or logs, 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.
+
+The detailed specification is written in the [Gherkin syntax](https://cucumber.io/docs/gherkin/reference/). The specification uses spans as an example, but the same applies to logs or any other future telemetry data.
+
+
+```Gherkin
+Scenario: No spans in BatchProcessor 1 span added
+    Given no spans in the BatchProcessor
+    When the SDK finishes 1 span
+    Then the SDK puts this span to the BatchProcessor
+    And starts a timeout of 5 seconds
+    And doesn't send the span to Sentry
+
+Scenario: Span added before timeout exceeds
+    Given span A in the BatchProcessor
+    Given 4.9 seconds pass
+    When the SDK finishes span B
+    Then the SDK adds span B to the BatchProcessor
+    And doesn't reset the timeout
+    And doesn't send the spans A and B in the BatchProcessor to Sentry
+
+Scenario: Spans with size of 1 MiB - 1 byte added, timeout exceeds
+    Given spans with size of 1 MiB - 1 byte in the BatchProcessor
+    When the timeout exceeds
+    Then the SDK adds all the spans to one envelope
+    And sends them to Sentry
+    And resets the timeout
+    And clears the BatchProcessor
+
+Scenario: Spans with size of 1 MiB - 1 byte added within 4.9 seconds
+    Given spans with size of 1 MiB - 1 byte in the BatchProcessor
+    When the SDK finishes another span and puts it into the BatchProcessor
+    Then the BatchProcessor puts all spans into one envelope
+    And sends the envelope to Sentry
+    And resets the timeout
+    And clears the BatchProcessor
+
+Scenario: Unfinished spans
+    Given no span is in the BatchProcessor
+    When the SDK starts a span but doesn't finish it
+    Then the BatchProcessor is empty
+
+Scenario: Span filtered out
+    Given no span is in the BatchProcessor
+    When the finishes a span
+    And the span is filtered out
+    Then the BatchProcessor is empty
+
+Scenario: Span not sampled
+    Given no span is in the BatchProcessor
+    When the finishes a span
+    And the span is not sampled
+    Then the BatchProcessor is empty
+
+Scenario: 1 span added application crashes
+  Given 1 span in the SpansAggregator
+  When the SDK detects a crash
+  Then the SDK does nothing with the items in the BatchProcessor
+  And loses the spans in the BatchProcessor
+
+```

develop-docs/self-hosted/troubleshooting/docker.mdx

@@ -4,6 +4,10 @@ sidebar_title: Docker
 sidebar_order: 3
 ---
 
+## `FAIL: Docker Compose is required to run self-hosted` error but Docker Compose is installed
+
+Around version 25.1.0 to 25.4.0, users which did not have `docker compose` plugin installed, and relied only on `docker-compose` will face some issues. Notably for Amazon Linux 2023 distro that does not have `docker-compose-plugin` packaged, you may need to install the standalone `docker-compose` separately. See [docker/compose installation guide](https://github.com/docker/compose?tab=readme-ov-file#linux) for more details.
+
 ## Container Healthcheck
 
 There may be some circumstances which you may want to increase or decrease healthcheck interval, timeout or retries for your custom needs. This can be achieved by editing `HEALTHCHECK_INTERVAL`, `HEALTHCHECK_TIMEOUT`, `HEALTHCHECK_RETRIES` variables' values in `.env`.

docs/platforms/go/common/tracing/instrumentation/custom-instrumentation/index.mdx

@@ -15,3 +15,94 @@ To capture transactions and spans customized to your organization's needs, you m
 <PlatformContent includePath="performance/add-spans-example" />
 
 <PlatformContent includePath="performance/retrieve-transaction" />
+
+## Adding Span & Transaction Data Attributes
+
+You can capture data attributes along with your spans and transactions. You can specify data attributes when starting a span or transaction:
+
+```go
+http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+  ctx := r.Context()
+
+  options := []sentry.SpanOption{
+    // Set the OP based on values from https://develop.sentry.dev/sdk/performance/span-operations/
+    sentry.WithOpName("http.server"),
+    sentry.ContinueFromRequest(r),
+    sentry.WithTransactionSource(sentry.SourceURL),
+  }
+
+  // Create a transaction and assign data attributes
+  transaction := sentry.StartTransaction(ctx,
+    fmt.Sprintf("%s %s", r.Method, r.URL.Path),
+    options...,
+  )
+  transaction.SetData("dataAttr1", 42)
+  transaction.SetData("dataAttr2", true)
+  // omitted code ...
+  transaction.Finish()
+
+  // ... or create a span and assign data attributes
+  span := sentry.StartSpan(ctx, "span1")
+  span.SetData("dataAttr1", 42)
+  span.SetData("dataAttr2", true)
+  // omitted code ...
+  span.Finish()
+})
+```
+
+Or you can add data attributes to an existing transaction or span:
+
+```go
+http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+  ctx := r.Context()
+  transaction := sentry.TransactionFromContext(ctx)
+
+  if transaction != nil {
+    transaction.SetData("dataAttr1", 42)
+    transaction.SetData("dataAttr2", true)
+  }
+
+  span := sentry.SpanFromContext(ctx)
+  span.SetData("dataAttr1", 42)
+  span.SetData("dataAttr2", true)
+})
+```
+
+Or you can update existing transaction and span data by:
+
+```go
+if d, found := transaction.Data["dataAttr1"]; found {
+  if dataAttr1, ok := d.(int); ok {
+    transaction.SetData("dataAttr1", dataAttr1.(int)+42)
+  }
+}
+
+if d, found := span.Data["dataAttr1"]; found {
+  if dataAttr1, ok := d.(int); ok {
+    span.SetData("dataAttr1", dataAttr1.(int)+42)
+  }
+}
+})
+```
+
+To attach data attributes to the transaction and all its spans, you can use `BeforeSendTransaction`:
+
+```go
+sentry.Init(sentry.ClientOptions{
+  Dsn: "___PUBLIC_DSN___",
+  BeforeSendTransaction: func(event *sentry.Event, hint *sentry.EventHint) *sentry.Event {
+    for _, sp := range event.Spans {
+      sp.SetData("dataAttr1", 42)
+      sp.SetData("dataAttr2", true)
+    }
+
+    dataCtx, ok := event.Contexts["trace"]["data"].(map[string]any)
+    if !ok {
+      dataCtx = make(map[string]any)
+      event.Contexts["trace"]["data"] = dataCtx
+    }
+    dataCtx["num"] = 42
+    return event
+  },
+})
+```

docs/platforms/godot/configuration/options.mdx

@@ -22,10 +22,18 @@ Learn more about [DSN utilization](/product/sentry-basics/dsn-explainer/#dsn-uti
 
 <ConfigKey name="debug">
 
-Turns debug mode on or off. If `debug` is enabled, the SDK will print useful debugging information to standard output. These messages do not appear in the Godot console or log file but can be seen when launching Godot application from a terminal. It's generally not recommended to turn it on in production, though turning `debug` mode on will not cause any safety concerns.
+Turns debug mode on or off. If `debug` is enabled, the SDK will print useful debugging information. You can see it in the Output panel of the Godot editor. It's generally not recommended to turn it on in production, though turning `debug` mode on will not cause any safety concerns.
 
 In the Project Settings, this option appears as `Debug Printing` and defaults to `Auto`. When set to `Auto`, the `debug` is enabled in debug builds (such as the editor and debug exports), and disabled in release export.
 
+You can control the verbosity using the `diagnostic_level` option.
+
+</ConfigKey>
+
+<ConfigKey name="diagnostic_level">
+
+Specifies the minimum level of messages to be printed if `debug` is turned on.
+
 </ConfigKey>
 
 <ConfigKey name="release">

docs/platforms/javascript/common/best-practices/index.mdx

@@ -1,7 +1,7 @@
 ---
 title: Special Use Cases
 description: "Learn how to set up Sentry for several specific use cases with these best practice guides."
-sidebar_order: 6
+sidebar_order: 8000
 notSupported:
   - javascript.node
   - javascript.aws-lambda