Merge branch 'v1.11' into issue_3592_3

daprdocs/content/en/concepts/building-blocks-concept.md

@@ -6,15 +6,15 @@ weight: 200
 description: "Modular best practices accessible over standard HTTP or gRPC APIs"
 ---
 
-A [building block]({{< ref building-blocks >}}) is an HTTP or gRPC API that can be called from your code and uses one or more Dapr components.
-
-Building blocks address common challenges in building resilient, microservices applications and codify best practices and patterns. Dapr consists of a set of building blocks, with extensibility to add new building blocks.
+A [building block]({{< ref building-blocks >}}) is an HTTP or gRPC API that can be called from your code and uses one or more Dapr components. Dapr consists of a set of API building blocks, with extensibility to add new building blocks. Dapr's building blocks:
+- Address common challenges in building resilient, microservices applications 
+- Codify best practices and patterns
 
 The diagram below shows how building blocks expose a public API that is called from your code, using components to implement the building blocks' capability.
 
 <img src="/images/concepts-building-blocks.png" width=250>
 
-The following are the building blocks provided by Dapr:
+Dapr provides the following building blocks:
 
 <img src="/images/building_blocks.png" width=1200>
 
@@ -25,7 +25,6 @@ The following are the building blocks provided by Dapr:
 | [**Publish and subscribe**]({{< ref "pubsub-overview.md" >}}) | `/v1.0/publish` `/v1.0/subscribe`|  Pub/Sub is a loosely coupled messaging pattern where senders (or publishers) publish messages to a topic, to which subscribers subscribe. Dapr supports the pub/sub pattern between applications.
 | [**Bindings**]({{< ref "bindings-overview.md" >}}) | `/v1.0/bindings` | A binding provides a bi-directional connection to an external cloud/on-premise service or system. Dapr allows you to invoke the external service through the  Dapr binding API, and it allows your application to be triggered by events sent by the connected service.
 | [**Actors**]({{< ref "actors-overview.md" >}}) | `/v1.0/actors` |  An actor is an isolated, independent unit of compute and state with single-threaded execution. Dapr provides an actor implementation based on the virtual actor pattern which provides a single-threaded programming model and where actors are garbage collected when not in use.
-| [**Observability**]({{< ref "observability-concept.md" >}}) | `N/A` |  Dapr system components and runtime emit metrics, logs, and traces to debug, operate and monitor Dapr system services, components and user applications.
 | [**Secrets**]({{< ref "secrets-overview.md" >}}) | `/v1.0/secrets` | Dapr provides a secrets building block API and integrates with secret stores such as public cloud stores, local stores and Kubernetes to store the secrets. Services can call the secrets API to retrieve secrets, for example to get a connection string to a database.
 | [**Configuration**]({{< ref "configuration-api-overview.md" >}}) | `/v1.0/configuration` | The Configuration API enables you to retrieve and subscribe to application configuration items for supported configuration stores. This enables an application to retrieve specific configuration information, for example, at start up or when configuration changes are made in the store. 
 | [**Distributed lock**]({{< ref "distributed-lock-api-overview.md" >}}) | `/v1.0-alpha1/lock` | The distributed lock API enables you to take a lock on a resource so that multiple instances of an application can access the resource without conflicts and provide consistency guarantees.  

daprdocs/content/en/concepts/components-concept.md

@@ -11,7 +11,7 @@ Dapr uses a modular design where functionality is delivered as a component. Each
 You can contribute implementations and extend Dapr's component interfaces capabilities via:
 
 - The [components-contrib repository](https://github.com/dapr/components-contrib)
-- [Pluggable components]({{<ref "components-concept.md#built-in-and-pluggable-components" >}}).
+- [Pluggable components]({{< ref "components-concept.md#built-in-and-pluggable-components" >}}).
 
 A building block can use any combination of components. For example, the [actors]({{< ref "actors-overview.md" >}}) and the [state management]({{< ref "state-management-overview.md" >}}) building blocks both use [state components](https://github.com/dapr/components-contrib/tree/master/state).
 

daprdocs/content/en/concepts/observability-concept.md

@@ -27,7 +27,7 @@ Maintaining this instrumentation code, which is not part of the core logic of th
 
 ## Observability for your application with Dapr
 
-When you leverage Dapr API building blocks to perform service-to-service calls and pub/sub messaging, Dapr offers an advantage with respect to [distributed tracing]({{< ref develop-tracing >}}). Since this inter-service communication flows through the Dapr runtime (or "sidecar"), Dapr is in a unique position to offload the burden of application-level instrumentation.
+When you leverage Dapr API building blocks to perform service-to-service calls, pub/sub messaging, and other APIs, Dapr offers an advantage with respect to [distributed tracing]({{< ref tracing >}}). Since this inter-service communication flows through the Dapr runtime (or "sidecar"), Dapr is in a unique position to offload the burden of application-level instrumentation.
 
 ### Distributed tracing
 
@@ -37,7 +37,7 @@ Dapr can be [configured to emit tracing data]({{< ref setup-tracing.md >}}) usin
 
 ### Automatic tracing context generation
 
-Dapr uses [W3C tracing]({{< ref w3c-tracing-overview >}}) specification for tracing context, included as part Open Telemetry (OTEL), to generate and propagate the context header for the application or propagate user-provided context headers. This means that you get tracing by default with Dapr.
+Dapr uses the [W3C tracing]({{< ref tracing >}}) specification for tracing context, included as part Open Telemetry (OTEL), to generate and propagate the context header for the application or propagate user-provided context headers. This means that you get tracing by default with Dapr.
 
 ## Observability for the Dapr sidecar and control plane
 
@@ -54,7 +54,7 @@ Dapr generates [logs]({{< ref logs.md >}}) to:
 - Provide visibility into sidecar operation 
 - Help users identify issues and perform debugging
 
-Log events contain warning, error, info, and debug messages produced by Dapr system services. You can also configure Dapr to send logs to collectors, such as Open Telemetry Collector, [Fluentd]({{< ref fluentd.md >}}), [New Relic]({{< ref "operations/monitoring/logging/newrelic.md" >}}), [Azure Monitor]({{< ref azure-monitor.md >}}), and other observability tools, so that logs can be searched and analyzed to provide insights.
+Log events contain warning, error, info, and debug messages produced by Dapr system services. You can also configure Dapr to send logs to collectors, such as [Open Telemetry Collector]({{< ref otel-collector >}}), [Fluentd]({{< ref fluentd.md >}}), [New Relic]({{< ref "operations/observability/logging/newrelic.md" >}}), [Azure Monitor]({{< ref azure-monitor.md >}}), and other observability tools, so that logs can be searched and analyzed to provide insights.
 
 ### Metrics
 
@@ -70,5 +70,5 @@ Conversely, Dapr can be configured to probe for the [health of your application]
 
 ## Next steps
 
-- [Learn more about observability in developing with Dapr]({{< ref develop-tracing >}})
+- [Learn more about observability in developing with Dapr]({{< ref tracing >}})
 - [Learn more about observability in operating with Dapr]({{< ref tracing >}})

daprdocs/content/en/concepts/overview.md

@@ -7,7 +7,7 @@ description: >
   Introduction to the Distributed Application Runtime
 ---
 
-Dapr is a portable, event-driven runtime that makes it easy for any developer to build resilient, stateless and stateful applications that run on the cloud and edge and embraces the diversity of languages and developer frameworks.
+Dapr is a portable, event-driven runtime that makes it easy for any developer to build resilient, stateless, and stateful applications that run on the cloud and edge and embraces the diversity of languages and developer frameworks.
 
 <div class="embed-responsive embed-responsive-16by9">
   <iframe width="1120" height="630" src="https://www.youtube-nocookie.com/embed/9o9iDAgYBA8" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
@@ -15,23 +15,32 @@ Dapr is a portable, event-driven runtime that makes it easy for any developer to
 
 ## Any language, any framework, anywhere
 
-<img src="/images/overview.png" width=1200>
+<img src="/images/overview.png" width=1200 style="padding-bottom:15px;">
 
-Today we are experiencing a wave of cloud adoption. Developers are comfortable with web + database application architectures, for example classic 3-tier designs, but not with microservice application architectures which are inherently distributed. It’s hard to become a distributed systems expert, nor should you have to. Developers want to focus on business logic, while leaning on the platforms to imbue their applications with scale, resiliency, maintainability, elasticity and the other attributes of cloud-native architectures.
+With the current wave of cloud adoption, web + database application architectures (such as classic 3-tier designs) are trending more toward microservice application architectures, which are inherently distributed. You shouldn't have to become a distributed systems expert just to create microservices applications. 
 
-This is where Dapr comes in. Dapr codifies the *best practices* for building microservice applications into open, independent APIs called building blocks, that enable you to build portable applications with the language and framework of your choice. Each building block is completely independent and you can use one, some, or all of them in your application.
+This is where Dapr comes in. Dapr codifies the *best practices* for building microservice applications into open, independent APIs called [building blocks]({{< ref "#microservice-building-blocks-for-cloud-and-edge" >}}). Dapr's building blocks:
+- Enable you to build portable applications using the language and framework of your choice. 
+- Are completely independent 
+- Have no limit to how many you use in your application
 
-Using Dapr you can incrementally migrate your existing applications to a microservices architecture, thereby adopting cloud native patterns such scale out/in, resiliency and independent deployments.
+Using Dapr, you can incrementally migrate your existing applications to a microservices architecture, thereby adopting cloud native patterns such scale out/in, resiliency, and independent deployments.
 
-In addition, Dapr is platform agnostic, meaning you can run your applications locally, on any Kubernetes cluster, on virtual or physical machines and in other hosting environments that Dapr integrates with. This enables you to build microservice applications that can run on the cloud and edge.
+Dapr is platform agnostic, meaning you can run your applications:
+- Locally
+- On any Kubernetes cluster
+- On virtual or physical machines 
+- In other hosting environments that Dapr integrates with. 
+
+This enables you to build microservice applications that can run on the cloud and edge.
 
 ## Microservice building blocks for cloud and edge
 
-<img src="/images/building_blocks.png" width=1200>
+<img src="/images/building_blocks.png" width=1200 style="padding-bottom:15px;">
 
-There are many considerations when architecting microservices applications. Dapr provides best practices for common capabilities when building microservice applications that developers can use in a standard way, and deploy to any environment. It does this by providing distributed system building blocks.
+Dapr provides distributed system building blocks for you to build microservice applications in a standard way and to deploy to any environment.
 
-Each of these building block APIs is independent, meaning that you can use one, some, or all of them in your application. The following building blocks are available:
+Each of these building block APIs is independent, meaning that you can use any number of them in your application. 
 
 | Building Block | Description |
 |----------------|-------------|
@@ -40,13 +49,22 @@ Each of these building block APIs is independent, meaning that you can use one,
 | [**Publish and subscribe**]({{< ref "pubsub-overview.md" >}}) | Publishing events and subscribing to topics between services enables event-driven architectures to simplify horizontal scalability and make them resilient to failure. Dapr provides at-least-once message delivery guarantee, message TTL, consumer groups and other advance features.
 | [**Resource bindings**]({{< ref "bindings-overview.md" >}}) | Resource bindings with triggers builds further on event-driven architectures for scale and resiliency by receiving and sending events to and from any external source such as databases, queues, file systems, etc.
 | [**Actors**]({{< ref "actors-overview.md" >}}) | A pattern for stateful and stateless objects that makes concurrency simple, with method and state encapsulation. Dapr provides many capabilities in its actor runtime, including concurrency, state, and life-cycle management for actor activation/deactivation, and timers and reminders to wake up actors.
-|  [**Observability**]({{< ref "observability-concept.md" >}}) | Dapr emits metrics, logs, and traces to debug and monitor both Dapr and user applications. Dapr supports distributed tracing to easily diagnose and serve inter-service calls in production using the W3C Trace Context standard and Open Telemetry to send to different monitoring tools.
 | [**Secrets**]({{< ref "secrets-overview.md" >}}) | The secrets management API integrates with public cloud and local secret stores to retrieve the secrets for use in application code.
 | [**Configuration**]({{< ref "configuration-api-overview.md" >}})  | The configuration API enables you to retrieve and subscribe to application configuration items from configuration stores. 
 | [**Distributed lock**]({{< ref "distributed-lock-api-overview.md" >}})  | The distributed lock API enables your application to acquire a lock for any resource that gives it exclusive access until either the lock is released by the application, or a lease timeout occurs. 
 | [**Workflows**]({{< ref "workflow-overview.md" >}}) | The workflow API can be combined with other Dapr building blocks to define long running, persistent processes or data flows that span multiple microservices using Dapr workflows or workflow components. 
 | [**Cryptography**]({{< ref "cryptography-overview.md" >}}) | The cryptography API provides an abstraction layer on top of security infrastructure such as key vaults. It contains APIs that allow you to perform cryptographic operations, such as encrypting and decrypting messages, without exposing keys to your applications.
 
+### Cross-cutting APIs
+
+Alongside its building blocks, Dapr provides cross-cutting APIs that apply across all the build blocks you use.
+
+| Building Block | Description |
+|----------------|-------------|
+|  [**Resiliency**]({{< ref "resiliency-concept.md" >}}) | Dapr provides the capability to define and apply fault tolerance resiliency policies via a resiliency spec. Supported specs define policies for resiliency patterns such as timeouts, retries/back-offs, and circuit breakers.
+|  [**Observability**]({{< ref "observability-concept.md" >}}) | Dapr emits metrics, logs, and traces to debug and monitor both Dapr and user applications. Dapr supports distributed tracing to easily diagnose and serve inter-service calls in production using the W3C Trace Context standard and Open Telemetry to send to different monitoring tools.
+|  [**Security**]({{< ref "security-concept.md" >}}) | Dapr supports in-transit encryption of communication between Dapr instances using the Dapr control plane, Sentry service. You can bring in your own certificates, or let Dapr automatically create and persist self-signed root and issuer certificates.
+
 ## Sidecar architecture
 
 Dapr exposes its HTTP and gRPC APIs as a sidecar architecture, either as a container or as a process, not requiring the application code to include any Dapr runtime code. This makes integration with Dapr easy from other runtimes, as well as providing separation of the application logic for improved supportability.
@@ -55,33 +73,41 @@ Dapr exposes its HTTP and gRPC APIs as a sidecar architecture, either as a conta
 
 ## Hosting environments
 
-Dapr can be hosted in multiple environments, including self-hosted on a Windows/Linux/macOS machines for local development and on Kubernetes or clusters of physical or virtual machines in production.
+Dapr can be hosted in multiple environments, including:
+- Self-hosted on a Windows/Linux/macOS machine for local development 
+- On Kubernetes or clusters of physical or virtual machines in production
 
 ### Self-hosted local development
 
-In [self-hosted mode]({{< ref self-hosted-overview.md >}}) Dapr runs as a separate sidecar process which your service code can call via HTTP or gRPC. Each running service has a Dapr runtime process (or sidecar) which is configured to use state stores, pub/sub, binding components and the other building blocks.
+In [self-hosted mode]({{< ref self-hosted-overview.md >}}), Dapr runs as a separate sidecar process, which your service code can call via HTTP or gRPC. Each running service has a Dapr runtime process (or sidecar) configured to use state stores, pub/sub, binding components, and the other building blocks.
 
-You can use the [Dapr CLI](https://github.com/dapr/cli#launch-dapr-and-your-app) to run a Dapr-enabled application on your local machine. The diagram below show Dapr's local development environment when configured with the CLI `init` command. Try this out with the [getting started samples]({{< ref getting-started >}}). 
+You can use the [Dapr CLI](https://github.com/dapr/cli#launch-dapr-and-your-app) to run a Dapr-enabled application on your local machine. In the following diagram, Dapr's local development environment gets configured with the CLI `init` command. Try this out with the [getting started samples]({{< ref getting-started >}}). 
 
 <img src="/images/overview-standalone.png" width=1200 alt="Architecture diagram of Dapr in self-hosted mode">
 
 ### Kubernetes
 
-Kubernetes can be used for either local development (for example with [minikube](https://minikube.sigs.k8s.io/docs/), [k3S](https://k3s.io/)) or in [production]({{< ref kubernetes >}}). In container hosting environments such as Kubernetes, Dapr runs as a sidecar container with the application container in the same pod.
+Kubernetes can be used for either:
+- Local development (for example, with [minikube](https://minikube.sigs.k8s.io/docs/) and [k3S](https://k3s.io/)), or 
+- In [production]({{< ref kubernetes >}}). 
 
-Dapr has control plane services. The `dapr-sidecar-injector` and `dapr-operator` services provide first-class integration to launch Dapr as a sidecar container in the same pod as the service container and provide notifications of Dapr component updates provisioned in the cluster.
+In container hosting environments such as Kubernetes, Dapr runs as a sidecar container with the application container in the same pod.
+
+Dapr's `dapr-sidecar-injector` and `dapr-operator` control plane services provide first-class integration to:
+- Launch Dapr as a sidecar container in the same pod as the service container 
+- Provide notifications of Dapr component updates provisioned in the cluster
 
 <!-- IGNORE_LINKS -->
 The `dapr-sentry` service is a certificate authority that enables mutual TLS between Dapr sidecar instances for secure data encryption, as well as providing identity via [Spiffe](https://spiffe.io/). For more information on the `Sentry` service, read the [security overview]({{< ref "security-concept.md#dapr-to-dapr-communication" >}})
 <!-- END_IGNORE -->
 
-Deploying and running a Dapr-enabled application into your Kubernetes cluster is as simple as adding a few annotations to the deployment schemes. Visit the [Dapr on Kubernetes docs]({{< ref kubernetes >}})
+Deploying and running a Dapr-enabled application into your Kubernetes cluster is as simple as adding a few annotations to the deployment schemes. Visit the [Dapr on Kubernetes docs]({{< ref kubernetes >}}).
 
 <img src="/images/overview-kubernetes.png" width=1200 alt="Architecture diagram of Dapr in Kubernetes mode">
 
 ### Clusters of physical or virtual machines
 
-The Dapr control plane services can be deployed in High Availability (HA) mode to clusters of physical or virtual machines in production, for example, as shown in the diagram below. Here the Actor `Placement` and `Sentry` services are started on three different VMs to provide HA control plane. In order to provide name resolution using DNS for the applications running in the cluster, Dapr uses [Hashicorp Consul service]({{< ref setup-nr-consul >}}), also running in HA mode.  
+The Dapr control plane services can be deployed in high availability (HA) mode to clusters of physical or virtual machines in production. In the diagram below, the Actor `Placement` and security `Sentry` services are started on three different VMs to provide HA control plane. In order to provide name resolution using DNS for the applications running in the cluster, Dapr uses [Hashicorp Consul service]({{< ref setup-nr-consul >}}), also running in HA mode.  
 
 <img src="/images/overview-vms-hosting.png" width=1200 alt="Architecture diagram of Dapr control plane and Consul deployed to VMs in high availability mode">
 
@@ -91,17 +117,15 @@ Dapr offers a variety of SDKs and frameworks to make it easy to begin developing
 
 ### Dapr SDKs
 
-To make using Dapr more natural for different languages, it also includes [language specific SDKs]({{<ref sdks>}}) for:
-- C++
+To make using Dapr more natural for different languages, it also includes [language specific SDKs]({{< ref sdks >}}) for:
 - Go
 - Java
 - JavaScript
 - .NET
 - PHP
 - Python
-- Rust
 
-These SDKs expose the functionality of the Dapr building blocks through a typed language API, rather than calling the http/gRPC API. This enables you to write a combination of stateless and stateful functions and actors all in the language of your choice. And because these SDKs share the Dapr runtime, you get cross-language actor and function support.
+These SDKs expose the functionality of the Dapr building blocks through a typed language API, rather than calling the http/gRPC API. This enables you to write a combination of stateless and stateful functions and actors all in the language of your choice. Since these SDKs share the Dapr runtime, you get cross-language actor and function support.
 
 ### Developer frameworks
 
@@ -120,7 +144,7 @@ Dapr can be used from any developer framework. Here are some that have been inte
 #### Integrations and extensions
 
 Visit the [integrations]({{< ref integrations >}}) page to learn about some of the first-class support Dapr has for various frameworks and external products, including:
-- Public cloud services
+- Public cloud services, like Azure and AWS
 - Visual Studio Code
 - GitHub
 
@@ -128,6 +152,6 @@ Visit the [integrations]({{< ref integrations >}}) page to learn about some of t
 
 Dapr is designed for [operations]({{< ref operations >}}) and security. The Dapr sidecars, runtime, components, and configuration can all be managed and deployed easily and securely to match your organization's needs.
 
-The [dashboard](https://github.com/dapr/dashboard), installed via the Dapr CLI, provides a web-based UI enabling you to see information, view logs and more for running Dapr applications.
+The [dashboard](https://github.com/dapr/dashboard), installed via the Dapr CLI, provides a web-based UI enabling you to see information, view logs, and more for running Dapr applications.
 
-The [monitoring tools support]({{< ref monitoring >}}) provides deeper visibility into the Dapr system services and side-cars and the [observability capabilities]({{<ref "observability-concept.md">}}) of Dapr provide insights into your application such as tracing and metrics.
+Dapr supports [monitoring tools]({{< ref observability >}}) for deeper visibility into the Dapr system services and sidecars, while the [observability capabilities]({{< ref "observability-concept.md" >}}) of Dapr provide insights into your application, such as tracing and metrics.

daprdocs/content/en/developing-applications/building-blocks/observability/develop-tracing/_index.md

@@ -1,7 +0,0 @@
----
-type: docs
-title: "Tracing"
-linkTitle: "Tracing"
-weight: 300
-description: Learn more about tracing scenarios and how to use tracing for visibility in your application
----

daprdocs/content/en/developing-applications/building-blocks/service-invocation/service-invocation-overview.md

@@ -135,5 +135,5 @@ For quick testing, try using the Dapr CLI for service invocation:
 ## Next steps
 - Read the [service invocation API specification]({{< ref service_invocation_api.md >}}). This reference guide for service invocation describes how to invoke methods on other services.
 - Understand the [service invocation performance numbers]({{< ref perf-service-invocation.md >}}).
-- Take a look at [observability]({{< ref monitoring.md >}}). Here you can dig into Dapr's monitoring tools like tracing, metrics and logging.
+- Take a look at [observability]({{< ref observability >}}). Here you can dig into Dapr's monitoring tools like tracing, metrics and logging.
 - Read up on our [security practices]({{< ref security-concept.md >}}) around mTLS encryption, token authentication, and endpoint authorization.

daprdocs/content/en/operations/hosting/kubernetes/kubernetes-production.md

@@ -226,7 +226,7 @@ To configure a tracing backend for Dapr visit [this]({{< ref "setup-tracing.md"
 
 For metrics, Dapr exposes a Prometheus endpoint listening on port 9090 which can be scraped by Prometheus.
 
-To setup Prometheus, Grafana and other monitoring tools with Dapr, visit [this]({{< ref "monitoring" >}}) link.
+To setup Prometheus, Grafana and other monitoring tools with Dapr, visit [this]({{< ref "observability" >}}) link.
 
 ## Injector watchdog
 

daprdocs/content/en/operations/monitoring/_index.md

@@ -1,7 +0,0 @@
----
-type: docs
-title: "Observe your application with Dapr"
-linkTitle: "Observability"
-weight: 80
-description: "How to observe and gain insights into your application"
----

daprdocs/content/en/operations/monitoring/tracing/_index.md

@@ -1,7 +0,0 @@
----
-type: docs
-title: "Tracing"
-linkTitle: "Tracing"
-weight: 100
-description: "How to setup your observability tools to receive application traces"
----

daprdocs/content/en/operations/observability/_index.md

@@ -11,5 +11,4 @@ description: See and measure the message calls to components and between network
  - Explore observability via any of the supporting [Dapr SDKs]({{< ref sdks >}}). 
  - Review the [Observability API reference documentation]({{< ref health_api.md >}}).
  - Read the [general overview of the observability concept]({{< ref observability-concept >}}) in Dapr.
- - Learn the [operations perspective and guidance on monitoring]({{< ref monitoring >}}).
 {{% /alert %}}

daprdocs/content/en/operations/observability/metrics/_index.md

@@ -1,7 +1,7 @@
 ---
 type: docs
 title: "Metrics"
-linkTitle: "View metrics"
+linkTitle: "Metrics"
 weight: 300
 description: "How to view Dapr metrics"
 ---

daprdocs/content/en/operations/observability/tracing/_index.md

@@ -0,0 +1,7 @@
+---
+type: docs
+title: "Tracing"
+linkTitle: "Tracing"
+weight: 200
+description: Learn about tracing scenarios and how to use tracing for visibility in your application
+---

daprdocs/content/en/operations/observability/tracing/setup-tracing.md

@@ -2,14 +2,14 @@
 type: docs
 title: "Configure Dapr to send distributed tracing data"
 linkTitle: "Configure tracing"
-weight: 100
-description: "Configure Dapr to send distributed tracing data"
+weight: 30
+description: "Set up Dapr to send distributed tracing data"
 ---
 
-It is recommended to run Dapr with tracing enabled for any production
-scenario.  You can configure Dapr to send tracing and telemetry data
-to many observability tools based on your environment, whether it is running in
-the cloud or on-premises.
+{{% alert title="Note" color="primary" %}}
+It is recommended to run Dapr with tracing enabled for any production scenario. You can configure Dapr to send tracing and telemetry data to many observability tools based on your environment, whether it is running in the cloud or on-premises.
+{{% /alert %}}
+
 
 ## Configuration
 
@@ -68,4 +68,13 @@ turns on tracing for the sidecar.
 |----------------------|-------------|
 | `OTEL_EXPORTER_OTLP_ENDPOINT` | Sets the Open Telemetry (OTEL) server address, turns on tracing |
 | `OTEL_EXPORTER_OTLP_INSECURE` | Sets the connection to the endpoint as unencrypted (true/false) |
-| `OTEL_EXPORTER_OTLP_PROTOCOL` | Transport protocol (`grpc`, `http/protobuf`, `http/json`) |
+| `OTEL_EXPORTER_OTLP_PROTOCOL` | Transport protocol (`grpc`, `http/protobuf`, `http/json`) |
+
+## Next steps
+
+Learn how to set up tracing with one of the following tools:
+- [OTEL Collector]({{< ref otel-collector >}})
+- [New Relic]({{< ref newrelic.md >}})
+- [Jaeger]({{< ref jaeger.md >}})
+- [Zipkin]({{< ref zipkin.md >}})
+- [Datadog]({{< ref datadog.md >}})

daprdocs/content/en/operations/observability/tracing/tracing-overview.md

@@ -1,9 +1,9 @@
 ---
 type: docs
-title: "Distributed tracing"
-linkTitle: "Distributed tracing"
-weight: 300
-description: "Use tracing to get visibility into your application"
+title: "Distributed tracing overview"
+linkTitle: "Overview"
+weight: 10
+description: "Overview on using tracing to get visibility into your application"
 ---
 
 Dapr uses the Open Telemetry (OTEL) and Zipkin protocols for distributed traces. OTEL is the industry standard and is the recommended trace protocol to use. 
@@ -17,6 +17,10 @@ Most observability tools support OTEL, including:
 - [Jaeger](https://www.jaegertracing.io/)
 - [SignalFX](https://www.signalfx.com/)
 
+The following diagram demonstrates how Dapr (using OTEL and Zipkin protocols) integrates with multiple observability tools.
+
+<img src="/images/observability-tracing.png" width=1000 alt="Distributed tracing with Dapr">
+
 ## Scenarios
 
 Tracing is used with service invocaton and pub/sub APIs. You can flow trace context between services that uses these APIs. There are two scenarios for how tracing is used:

daprdocs/content/en/operations/observability/tracing/w3c-tracing-overview.md

@@ -1,10 +1,9 @@
 ---
 type: docs
-title: "W3C trace context"
+title: "W3C trace context overview"
 linkTitle: "W3C trace context"
-weight: 2000
-description: Background and scenarios for using W3C tracing with Dapr
-type: docs
+weight: 20
+description: Background and scenarios for using W3C tracing context and headers with Dapr
 ---
 
 Dapr uses the [Open Telemetry protocol](https://opentelemetry.io/), which in turn uses the [W3C trace context](https://www.w3.org/TR/trace-context/) for distributed tracing for both service invocation and pub/sub messaging. Dapr generates and propagates the trace context information, which can be sent to observability tools for visualization and querying.

daprdocs/content/en/operations/resiliency/health-checks/_index.md

@@ -0,0 +1,7 @@
+---
+type: docs
+title: "Health checks"
+linkTitle: "Health checks"
+weight: 400
+description: "How to setup health checks for the Dapr sidecar and your application"
+---

daprdocs/content/en/operations/resiliency/policies.md

@@ -1,8 +1,8 @@
 ---
 type: docs
-title: "Policies"
+title: "Resiliency policies"
 linkTitle: "Policies"
-weight: 4500
+weight: 200
 description: "Configure resiliency policies for timeouts, retries, and circuit breakers"
 ---
 

daprdocs/content/en/operations/resiliency/resiliency-overview.md

@@ -2,7 +2,7 @@
 type: docs
 title: "Overview"
 linkTitle: "Overview"
-weight: 4500
+weight: 100
 description: "Configure Dapr retries, timeouts, and circuit breakers"
 ---
 

daprdocs/content/en/operations/resiliency/targets.md

@@ -2,8 +2,8 @@
 type: docs
 title: "Targets"
 linkTitle: "Targets"
-weight: 4500
-description: "Apply resiliency policies to apps, components and actors"
+weight: 300
+description: "Apply resiliency policies to targets including apps, components and actors"
 ---
 
 ### Targets