From ff8c47ab98c27e661e0e5f4a3ba6c43f8293862e Mon Sep 17 00:00:00 2001 From: Dominique Alessi Date: Tue, 23 Dec 2025 16:59:13 -0500 Subject: [PATCH 1/4] instrumentation landing page rework --- content/en/tracing/trace_collection/_index.md | 174 +++++++++++++----- 1 file changed, 124 insertions(+), 50 deletions(-) diff --git a/content/en/tracing/trace_collection/_index.md b/content/en/tracing/trace_collection/_index.md index 24146a34f67..88fd72185fe 100644 --- a/content/en/tracing/trace_collection/_index.md +++ b/content/en/tracing/trace_collection/_index.md @@ -31,100 +31,174 @@ algolia: To get started with Datadog APM, you need to follow these key steps: -1. Install and configure the Datadog Agent. -2. Instrument your application. +1. Install and configure the Datadog Agent. +2. Add the Datadog tracing SDK to your application. +3. Instrument your application to create spans. -
Simplify your setup! Install the Agent and instrument your application in one step with Single Step Instrumentation.
+
+Simplify your setup! +Use Single Step Instrumentation to complete these steps in one command. +
-Instrumenting your application allows observability data to be sent to the Agent, which then passes data to the Datadog backend to display in the UI. +Instrumenting your application creates spans that are sent to the Datadog Agent, which forwards trace data to the Datadog backend for visualization and analysis. {{< img src="tracing/visualization/troubleshooting_pipeline.png" alt="The APM pipeline">}} +## Instrumentation model -## Instrumentation types +
+If you prefer vendor-neutral instrumentation, see the OpenTelemetry documentation for using OpenTelemetry API support in Datadog libraries. +
-There are two main approaches to {{< tooltip glossary="instrument" >}} your application: +At a high level, {{< tooltip glossary="instrument" >}}ing an application with Datadog APM involves two actions: -**Automatic instrumentation** creates {{< tooltip glossary="span" >}}s for your application with minimal manual steps, capturing essential observability data across common libraries and languages with minimal configuration. +1. Adding the Datadog language SDKs to your application. +2. Creating {{< tooltip glossary="span" >}}s to capture observability data. -**Custom instrumentation** captures observability data from in-house code or complex functions that aren't captured by automatic instrumentation, providing deeper visibility and context into spans when you need fine-grained control. +Datadog language SDKs automatically create spans for supported frameworks and libraries. In many cases, this automatic instrumentation is sufficient. When you need more control, you can add custom instrumentation. -The following table compares the different instrumentation methods available. -
-If you prefer vendor-neutral instrumentation, see the OpenTelemetry documentation for using OpenTelemetry API support in Datadog libraries. -
+### Adding Datadog language SDKs + +Datadog language SDKs can be added to your application in the following ways: + +- **Single Step Instrumentation (SSI)**: Automatically installs and loads Datadog language SDKs at runtime. +- **Manual installation**: Install and configure the Datadog language SDKs directly in your application. + + +### Creating spans + +After Datadog language SDKs are available, spans can be created in the following ways: + +- **Automatic instrumentation**: Datadog language SDKs automatically create spans to capture essential observability data across common libraries and languages. +- **Custom instrumentation**: Add spans for custom code paths or specialized logic. You can create custom spans in two ways: + - **Code-based custom instrumentation**: Use the Datadog tracing APIs in your application code. + - **Dynamic Instrumentation (UI-based custom instrumentation)**: Add spans at runtime using configuration in the Datadog UI, without modifying application code. + +## Summary + +The following table compares the available ways to install Datadog language SDKs and create spans. In most cases, you install the SDK and rely on automatic instrumentation, then optionally add custom instrumentation if you need more control. - - - - + + - + + - - - - - - - - + - - - - + + + + + + + + + + + + + + + + + + + + + + + + - + - + + + - + - + + + - + + + - - - - + + + + + + - From 067d8098617bc7da030f11c19fff9184a06a5e1b Mon Sep 17 00:00:00 2001 From: Dominique Alessi Date: Tue, 13 Jan 2026 17:20:16 -0500 Subject: [PATCH 2/4] rework instrumentation landing page per feedback --- content/en/tracing/trace_collection/_index.md | 241 +++++++++--------- 1 file changed, 119 insertions(+), 122 deletions(-) diff --git a/content/en/tracing/trace_collection/_index.md b/content/en/tracing/trace_collection/_index.md index 88fd72185fe..683ff4c6473 100644 --- a/content/en/tracing/trace_collection/_index.md +++ b/content/en/tracing/trace_collection/_index.md @@ -28,186 +28,177 @@ algolia: --- ## Overview +Application {{< tooltip glossary="instrumentation" >}} with Datadog APM involves two steps: -To get started with Datadog APM, you need to follow these key steps: +1. **SDK setup**: Adding the Datadog tracing SDK to your application. +2. **Span creation**: Capturing observability data as {{< tooltip glossary="span" >}}s. -1. Install and configure the Datadog Agent. -2. Add the Datadog tracing SDK to your application. -3. Instrument your application to create spans. +Spans are automatically generated by default as soon as the SDK is loaded. For most users, this automatic span creation provides sufficient visibility. If you need more control, you can optionally add custom spans. + +{{< img src="tracing/visualization/troubleshooting_pipeline.png" alt="The APM pipeline">}} + +## Choose your path
-Simplify your setup! -Use Single Step Instrumentation to complete these steps in one command. +Prefer vendor-neutral instrumentation? See the OpenTelemetry documentation for using OpenTelemetry with Datadog.
-Instrumenting your application creates spans that are sent to the Datadog Agent, which forwards trace data to the Datadog backend for visualization and analysis. +### Zero-code instrumentation -{{< img src="tracing/visualization/troubleshooting_pipeline.png" alt="The APM pipeline">}} +**Best for**: Teams that want tracing without modifying application code. -## Instrumentation model +Use [Single Step Instrumentation][1] to automatically install SDKs, and optionally add [Dynamic Instrumentation][4] to customize spans from the Datadog UI. -
-If you prefer vendor-neutral instrumentation, see the OpenTelemetry documentation for using OpenTelemetry API support in Datadog libraries. -
+{{< whatsnext desc=" " >}} + {{< nextlink href="/tracing/trace_collection/single-step-apm/" >}}Get started with Single Step Instrumentation{{< /nextlink >}} + {{< nextlink href="/tracing/trace_collection/dynamic_instrumentation/" >}}Add custom spans with Dynamic Instrumentation{{< /nextlink >}} +{{< /whatsnext >}} + +### Code-based instrumentation -At a high level, {{< tooltip glossary="instrument" >}}ing an application with Datadog APM involves two actions: +**Best for**: Teams that want full control over SDK configuration and span creation. -1. Adding the Datadog language SDKs to your application. -2. Creating {{< tooltip glossary="span" >}}s to capture observability data. +Use [Datadog tracing libraries][2] to manually configure SDKs, and optionally add [code-based custom instrumentation][3] to create custom spans. + +{{< whatsnext desc=" " >}} + {{< nextlink href="/tracing/trace_collection/dd_libraries/" >}}Get started with Datadog tracing libraries{{< /nextlink >}} + {{< nextlink href="/tracing/trace_collection/custom_instrumentation/" >}}Add custom spans with code-based instrumentation{{< /nextlink >}} +{{< /whatsnext >}} -Datadog language SDKs automatically create spans for supported frameworks and libraries. In many cases, this automatic instrumentation is sufficient. When you need more control, you can add custom instrumentation. +## How instrumentation works +### SDK setup -### Adding Datadog language SDKs +The first step is adding the Datadog tracing SDK to your application. You have two options: -Datadog language SDKs can be added to your application in the following ways: +| Method | Description | Code changes? | Best for | +|--------|-------------|--------------|----------| +| [**Single Step Instrumentation (SSI)**][1] | Automatically installs and loads SDKs at runtime with a single command. | No | SREs and platform teams who want tracing across services without developer involvement. | +| [**Datadog tracing libraries**][2] | Manually install and configure SDKs in your application. | Yes | Development teams who need granular control over SDK configuration. | -- **Single Step Instrumentation (SSI)**: Automatically installs and loads Datadog language SDKs at runtime. -- **Manual installation**: Install and configure the Datadog language SDKs directly in your application. +### Span creation +After the SDK is loaded, spans are automatically created for supported frameworks and libraries. This automatic span creation captures essential observability data with no additional work required. -### Creating spans +If you need visibility into custom code paths or want to enrich traces with application-specific data, you can add custom spans: -After Datadog language SDKs are available, spans can be created in the following ways: +| Method | Description | Code changes? | Best for | +|--------|-------------|--------------|----------| +| [**Code-based custom instrumentation**][3] | Add spans programmatically using Datadog tracing APIs. | Yes | Teams that need custom logic, specialized spans, or visibility into custom code paths. | +| [**Dynamic Instrumentation**][4] | Add spans at runtime from the Datadog UI without code changes. | No | Teams that want to add spans without redeploying or modifying source code. | -- **Automatic instrumentation**: Datadog language SDKs automatically create spans to capture essential observability data across common libraries and languages. -- **Custom instrumentation**: Add spans for custom code paths or specialized logic. You can create custom spans in two ways: - - **Code-based custom instrumentation**: Use the Datadog tracing APIs in your application code. - - **Dynamic Instrumentation (UI-based custom instrumentation)**: Add spans at runtime using configuration in the Datadog UI, without modifying application code. +## Decision guide -## Summary +Use this guide to determine which combination of methods fits your needs: -The following table compares the available ways to install Datadog language SDKs and create spans. In most cases, you install the SDK and rely on automatic instrumentation, then optionally add custom instrumentation if you need more control. +| Goal | SDK setup | Span creation | +|------|-----------|---------------| +| Get started with minimal effort | [Single Step Instrumentation][1] | Automatic (built-in) | +| Control SDK configuration but use automatic spans | [Datadog tracing libraries][2] | Automatic (built-in) | +| Automatically load SDKs and customize spans without code changes | [Single Step Instrumentation][1] | [Dynamic Instrumentation][4] | +| Automatically load SDKs and customize spans in code | [Single Step Instrumentation][1] | [Code-based custom instrumentation][3] | +| Manually configure SDKs and customize spans without code changes | [Datadog tracing libraries][2] | [Dynamic Instrumentation][4] | +| Have full control over both SDK setup and span creation | [Datadog tracing libraries][2] | [Code-based custom instrumentation][3] | + +## Detailed comparison + +### SDK setup options
- Automatic Instrumentation +
+ + Single Step Instrumentation + - Custom Instrumentation + + + Manually managed SDKs + + + + Code-based Custom Instrumentation + + + + Dynamic Instrumentation +
Single Step InstrumentationManually managed SDKsCode-based Custom InstrumentationDynamic Instrumentation
(UI-based Custom Instrumentation)
DescriptionWith a single command, Datadog automatically loads language SDKs to your application processes. You can also control which processes to instrument.Add Datadog language SDKs to your applications. The SDK handles instrumentation automatically.Add explicit tracing API calls or span logic in your application code.Add instrumentation rules in the Datadog UI. Rules are applied dynamically at runtime and do not require code changes. + With a single command, Datadog automatically loads language SDKs to your application processes. You can also control which processes to instrument. + + Add Datadog language SDKs to your applications. The SDK handles instrumentation automatically. + + Add explicit tracing API calls or span logic in your application code. + + Add instrumentation rules in the Datadog UI. Rules are applied dynamically at runtime and do not require code changes. +
Installs Datadog language SDKs?Yes (automatic)Yes (manual)NoNo
Instrumentation behaviorAutomaticAutomaticCustom (code-based)Custom (runtime, UI-based)
Code changes?Code changes required NoNoYes Yes No
Environment config changes?Runtime or environment configuration required NoYesYes Yes No
Setup complexity LowMediumMedium High Low
Best forSRE, admins, or central teams who want tracing across services without developer involvement.App dev teams who want to instrument applications individually with granular control over configuration through environment variables.Teams needing custom logic, specialized spans, or visibility into custom code paths.Teams wanting to add spans, logs, or metrics to specific code locations at runtime without redeploying or modifying source code. Configuration is managed through the Datadog UI. + SRE, admins, or central teams who want tracing across services without developer involvement. + + App dev teams who want to instrument applications individually with granular control over configuration through environment variables. + + Teams needing custom logic, specialized spans, or visibility into custom code paths. + + Teams wanting to add spans, logs, or metrics to specific code locations at runtime without redeploying or modifying source code. Configuration is managed through the Datadog UI. +
Use cases -
    -
  • Capturing essential observability data across common libraries and languages with minimal configuration.
    • -
  • Enabling real-time monitoring with pre-configured settings for immediate insights into application performance.
    • -
  • Simplifying the observability setup for projects where custom instrumentation is not required.
    • +
+
    +
  • Capturing essential observability data across common libraries and languages with minimal configuration.
    • +
  • Enabling real-time monitoring with pre-configured settings for immediate insights into application performance.
    • +
  • Simplifying the observability setup for projects where custom instrumentation is not required.
 -
    -
  • Collecting observability data from custom code with unique or complex business logic.
    • -
  • Providing deeper visibility and context into spans, including adding span tags.
    • -
  • Precisely monitoring specific sequences of operations or user interactions that require fine-grained control.
    • -
  • Removing unwanted spans from traces.
    • +
      +
    • Collecting observability data from custom code with unique or complex business logic.
      • +
    • Enriching traces with application-specific metadata.
      • +
    • Precisely monitoring sequences of operations or user interactions that require fine-grained control.
      • +
    • Removing unwanted spans from traces.
- - - - + + - - - - - - - + + + - - - - - - + + + + + + + + + + + + - - - - - - - + + + + + + + + +
- - Single Step Instrumentation - - - - Manually managed SDKs - - - - Code-based Custom Instrumentation - - - - Dynamic Instrumentation - - Single Step InstrumentationDatadog tracing libraries
Description - With a single command, Datadog automatically loads language SDKs to your application processes. You can also control which processes to instrument. - - Add Datadog language SDKs to your applications. The SDK handles instrumentation automatically. - - Add explicit tracing API calls or span logic in your application code. - - Add instrumentation rules in the Datadog UI. Rules are applied dynamically at runtime and do not require code changes. - How it worksDatadog automatically loads SDKs into your application processes with a single command.You install and configure SDKs directly in your application code or build process.
Installs Datadog language SDKs?Yes (automatic)Yes (manual)NoCode changes? NoYes
Environment configurationMinimalRequired
Setup complexityLowMedium
Instrumentation behaviorAutomaticAutomaticCustom (code-based)Custom (runtime, UI-based)Configuration controlStandard defaults with optional overridesFull control through environment variables and code
Best forSREs, platform teams, and organizations wanting fast, consistent instrumentation across services.Development teams needing granular control over SDK behavior and configuration.
+ +### Span customization options - + + + + + + - - - + + + + + + - - - - - - + + - - + - - - - - - - - - - - - - - - - + + + + +
Code-based custom instrumentationDynamic Instrumentation
Code changes requiredNoYesHow it worksAdd explicit tracing API calls in your application code.Configure instrumentation rules in the Datadog UI; rules are applied at runtime.
Code changes? Yes No
Runtime or environment configuration requiredNoYesYesDeployment requiredYes (to add or modify spans) No
Setup complexityMedium to high LowMediumHighLow
Best for - SRE, admins, or central teams who want tracing across services without developer involvement. - - App dev teams who want to instrument applications individually with granular control over configuration through environment variables. - - Teams needing custom logic, specialized spans, or visibility into custom code paths. - - Teams wanting to add spans, logs, or metrics to specific code locations at runtime without redeploying or modifying source code. Configuration is managed through the Datadog UI. -
Use cases +
    -
  • Capturing essential observability data across common libraries and languages with minimal configuration.
    • -
  • Enabling real-time monitoring with pre-configured settings for immediate insights into application performance.
    • -
  • Simplifying the observability setup for projects where custom instrumentation is not required.
    • +
  • Instrumenting custom business logic
    • +
  • Adding application-specific metadata to spans
    • +
  • Removing unwanted spans from traces
    • +
  • Complex span manipulation
 +
    -
  • Collecting observability data from custom code with unique or complex business logic.
    • -
  • Enriching traces with application-specific metadata.
    • -
  • Precisely monitoring sequences of operations or user interactions that require fine-grained control.
    • -
  • Removing unwanted spans from traces.
    • +
  • Adding spans to production without redeploying
    • +
  • Debugging specific code paths
    • +
  • Adding logs or metrics at runtime
    • +
  • Fast instrumentation changes
Best forTeams with complex instrumentation needs who want spans defined in code.Teams wanting to add or modify spans without code changes or redeployments.
- ## APM setup tutorials -The following tutorials guide you through setting up distributed tracing for a sample application on various infrastructure scenarios, with both automatic and custom instrumentation, using the Datadog tracing libraries: +The following tutorials guide you through setting up distributed tracing for a sample application on various infrastructure scenarios, with both automatic and custom instrumentation: {{< whatsnext desc="Choose your language and environment:" >}} {{< nextlink href="tracing/guide/tutorial-enable-python-host" >}} Enabling Tracing on a Python Application on the Same Host as Datadog Agent{{< /nextlink >}} @@ -217,7 +208,7 @@ The following tutorials guide you through setting up distributed tracing for a s {{< nextlink href="tracing/guide/tutorial-enable-java-containers" >}} Enabling Tracing on a Java Application and Datadog Agent in Containers{{< /nextlink >}} {{< nextlink href="tracing/guide/tutorial-enable-java-container-agent-host" >}} Enabling Tracing for a Java Application in a Container and an Agent on a Host{{< /nextlink >}} {{< nextlink href="tracing/guide/tutorial-enable-java-gke" >}} Enabling Tracing for a Java Application on GKE{{< /nextlink >}} - {{< nextlink href="tracing/guide/tutorial-enable-java-aws-eks" >}} Enabling Tracing for a Java Application on AWS EKS{{< /nextlink >}} + {{< nextlink href="tracing/guide/tutorial-enable-java-aws-eks" >}} Enabling Tracing for a Java Application on Amazon EKS{{< /nextlink >}} {{< nextlink href="tracing/guide/tutorial-enable-java-aws-ecs-ec2" >}} Enabling Tracing for a Java Application in Amazon ECS with EC2{{< /nextlink >}} {{< nextlink href="tracing/guide/tutorial-enable-java-aws-ecs-fargate" >}} Enabling Tracing for a Java Application in Amazon ECS with Fargate{{< /nextlink >}} {{< nextlink href="tracing/guide/tutorial-enable-java-admission-controller" >}} Enabling Tracing for a Java Application with the Admission Controller{{< /nextlink >}} @@ -227,7 +218,13 @@ The following tutorials guide you through setting up distributed tracing for a s {{< nextlink href="tracing/guide/tutorial-enable-go-aws-ecs-fargate" >}} Enabling Tracing for a Go Application in Amazon ECS with Fargate{{< /nextlink >}} {{< /whatsnext >}} + ## Further reading {{< partial name="whats-next/whats-next.html" >}} +[1]: /tracing/trace_collection/single-step-apm/ +[2]: /tracing/trace_collection/dd_libraries/ +[3]: /tracing/trace_collection/custom_instrumentation/ +[4]: /tracing/trace_collection/dynamic_instrumentation/ + From 592ed3e1b4fd8f72ffeb3c98fc8a5f5198a8cd97 Mon Sep 17 00:00:00 2001 From: Dominique Alessi Date: Tue, 13 Jan 2026 17:36:34 -0500 Subject: [PATCH 3/4] language refinements --- content/en/tracing/trace_collection/_index.md | 27 ++++++++++--------- 1 file changed, 15 insertions(+), 12 deletions(-) diff --git a/content/en/tracing/trace_collection/_index.md b/content/en/tracing/trace_collection/_index.md index 683ff4c6473..0f15fc8fdc9 100644 --- a/content/en/tracing/trace_collection/_index.md +++ b/content/en/tracing/trace_collection/_index.md @@ -30,11 +30,13 @@ algolia: ## Overview Application {{< tooltip glossary="instrumentation" >}} with Datadog APM involves two steps: -1. **SDK setup**: Adding the Datadog tracing SDK to your application. +1. **SDK setup**: Adding a Datadog SDK to your application. 2. **Span creation**: Capturing observability data as {{< tooltip glossary="span" >}}s. Spans are automatically generated by default as soon as the SDK is loaded. For most users, this automatic span creation provides sufficient visibility. If you need more control, you can optionally add custom spans. +**Note**: These steps assume you have a [Datadog Agent][5] installed and configured to receive traces. + {{< img src="tracing/visualization/troubleshooting_pipeline.png" alt="The APM pipeline">}} ## Choose your path @@ -43,25 +45,25 @@ Spans are automatically generated by default as soon as the SDK is loaded. For m Prefer vendor-neutral instrumentation? See the OpenTelemetry documentation for using OpenTelemetry with Datadog. -### Zero-code instrumentation +### No code changes **Best for**: Teams that want tracing without modifying application code. -Use [Single Step Instrumentation][1] to automatically install SDKs, and optionally add [Dynamic Instrumentation][4] to customize spans from the Datadog UI. +Use [Single Step Instrumentation][1] to automatically install Datadog SDKs. If you need custom spans, you can also use [Dynamic Instrumentation][4] to add them from the Datadog UI without changing code. {{< whatsnext desc=" " >}} {{< nextlink href="/tracing/trace_collection/single-step-apm/" >}}Get started with Single Step Instrumentation{{< /nextlink >}} {{< nextlink href="/tracing/trace_collection/dynamic_instrumentation/" >}}Add custom spans with Dynamic Instrumentation{{< /nextlink >}} {{< /whatsnext >}} -### Code-based instrumentation +### Code-based setup and customization **Best for**: Teams that want full control over SDK configuration and span creation. -Use [Datadog tracing libraries][2] to manually configure SDKs, and optionally add [code-based custom instrumentation][3] to create custom spans. +Use [Datadog SDKs][2] to manually configure instrumentation. If you need custom spans, you can also add [code-based custom instrumentation][3]. {{< whatsnext desc=" " >}} - {{< nextlink href="/tracing/trace_collection/dd_libraries/" >}}Get started with Datadog tracing libraries{{< /nextlink >}} + {{< nextlink href="/tracing/trace_collection/dd_libraries/" >}}Get started with Datadog SDKs{{< /nextlink >}} {{< nextlink href="/tracing/trace_collection/custom_instrumentation/" >}}Add custom spans with code-based instrumentation{{< /nextlink >}} {{< /whatsnext >}} @@ -69,12 +71,12 @@ Use [Datadog tracing libraries][2] to manually configure SDKs, and optionally ad ### SDK setup -The first step is adding the Datadog tracing SDK to your application. You have two options: +The first step is adding a Datadog SDK to your application. You have two options: | Method | Description | Code changes? | Best for | |--------|-------------|--------------|----------| | [**Single Step Instrumentation (SSI)**][1] | Automatically installs and loads SDKs at runtime with a single command. | No | SREs and platform teams who want tracing across services without developer involvement. | -| [**Datadog tracing libraries**][2] | Manually install and configure SDKs in your application. | Yes | Development teams who need granular control over SDK configuration. | +| [**Datadog SDKs**][2] | Manually install and configure SDKs in your application. | Yes | Development teams who need granular control over SDK configuration. | ### Span creation @@ -94,11 +96,11 @@ Use this guide to determine which combination of methods fits your needs: | Goal | SDK setup | Span creation | |------|-----------|---------------| | Get started with minimal effort | [Single Step Instrumentation][1] | Automatic (built-in) | -| Control SDK configuration but use automatic spans | [Datadog tracing libraries][2] | Automatic (built-in) | +| Control SDK configuration but use automatic spans | [Datadog SDKs][2] | Automatic (built-in) | | Automatically load SDKs and customize spans without code changes | [Single Step Instrumentation][1] | [Dynamic Instrumentation][4] | | Automatically load SDKs and customize spans in code | [Single Step Instrumentation][1] | [Code-based custom instrumentation][3] | -| Manually configure SDKs and customize spans without code changes | [Datadog tracing libraries][2] | [Dynamic Instrumentation][4] | -| Have full control over both SDK setup and span creation | [Datadog tracing libraries][2] | [Code-based custom instrumentation][3] | +| Manually configure SDKs and customize spans without code changes | [Datadog SDKs][2] | [Dynamic Instrumentation][4] | +| Have full control over both SDK setup and span creation | [Datadog SDKs][2] | [Code-based custom instrumentation][3] | ## Detailed comparison @@ -108,7 +110,7 @@ Use this guide to determine which combination of methods fits your needs: Single Step Instrumentation - Datadog tracing libraries + Datadog SDKs How it works @@ -227,4 +229,5 @@ The following tutorials guide you through setting up distributed tracing for a s [2]: /tracing/trace_collection/dd_libraries/ [3]: /tracing/trace_collection/custom_instrumentation/ [4]: /tracing/trace_collection/dynamic_instrumentation/ +[5]: /agent/ From bb36ebf1310295156a807eef79dc2575afa8604f Mon Sep 17 00:00:00 2001 From: Dominique Alessi Date: Wed, 21 Jan 2026 17:37:15 -0500 Subject: [PATCH 4/4] address feedback from sarjeel --- content/en/tracing/trace_collection/_index.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/content/en/tracing/trace_collection/_index.md b/content/en/tracing/trace_collection/_index.md index 0f15fc8fdc9..071e4dcbdd7 100644 --- a/content/en/tracing/trace_collection/_index.md +++ b/content/en/tracing/trace_collection/_index.md @@ -49,7 +49,7 @@ Spans are automatically generated by default as soon as the SDK is loaded. For m **Best for**: Teams that want tracing without modifying application code. -Use [Single Step Instrumentation][1] to automatically install Datadog SDKs. If you need custom spans, you can also use [Dynamic Instrumentation][4] to add them from the Datadog UI without changing code. +Use [Single Step Instrumentation][1] to automatically set up Datadog SDKs. If you need custom spans, you can also use [Dynamic Instrumentation][4] to add them from the Datadog UI without changing code. {{< whatsnext desc=" " >}} {{< nextlink href="/tracing/trace_collection/single-step-apm/" >}}Get started with Single Step Instrumentation{{< /nextlink >}} @@ -76,11 +76,11 @@ The first step is adding a Datadog SDK to your application. You have two options | Method | Description | Code changes? | Best for | |--------|-------------|--------------|----------| | [**Single Step Instrumentation (SSI)**][1] | Automatically installs and loads SDKs at runtime with a single command. | No | SREs and platform teams who want tracing across services without developer involvement. | -| [**Datadog SDKs**][2] | Manually install and configure SDKs in your application. | Yes | Development teams who need granular control over SDK configuration. | +| [**Manual SDK setup**][2] | Manually install and configure SDKs in your application. | Yes | Development teams who need granular control over SDK configuration. | ### Span creation -After the SDK is loaded, spans are automatically created for supported frameworks and libraries. This automatic span creation captures essential observability data with no additional work required. +After the SDK is loaded, spans are automatically created through auto-instrumentation for supported frameworks and libraries. This automatic span creation captures essential observability data with no additional work required. If you need visibility into custom code paths or want to enrich traces with application-specific data, you can add custom spans: @@ -95,8 +95,8 @@ Use this guide to determine which combination of methods fits your needs: | Goal | SDK setup | Span creation | |------|-----------|---------------| -| Get started with minimal effort | [Single Step Instrumentation][1] | Automatic (built-in) | -| Control SDK configuration but use automatic spans | [Datadog SDKs][2] | Automatic (built-in) | +| Get started with minimal effort | [Single Step Instrumentation][1] | Auto-instrumentation | +| Manually control SDK setup but use auto-instrumentation to capture spans | [Datadog SDKs][2] | Auto-instrumentation | | Automatically load SDKs and customize spans without code changes | [Single Step Instrumentation][1] | [Dynamic Instrumentation][4] | | Automatically load SDKs and customize spans in code | [Single Step Instrumentation][1] | [Code-based custom instrumentation][3] | | Manually configure SDKs and customize spans without code changes | [Datadog SDKs][2] | [Dynamic Instrumentation][4] |