Merge branch 'v1.11' into ts-azure-app-config-subscribe-interval

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

@@ -7,42 +7,68 @@ description: >
   Observe applications through tracing, metrics, logs and health
 ---
 
-When building an application, understanding how the system is behaving is an important part of operating it - this includes having the ability to observe the internal calls of an application, gauging its performance and becoming aware of problems as soon as they occur. This is challenging for any system, but even more so for a distributed system comprised of multiple microservices where a flow, made of several calls, may start in one microservice but continue in another. Observability is critical in production environments, but also useful during development to understand bottlenecks, improve performance and perform basic debugging across the span of microservices.
+When building an application, understanding the system behavior is an important, yet challenging part of operating it, such as:
+- Observing the internal calls of an application
+- Gauging its performance
+- Becoming aware of problems as soon as they occur 
 
-While some data points about an application can be gathered from the underlying infrastructure (for example memory consumption, CPU usage), other meaningful information must be collected from an "application-aware" layer–one that can show how an important series of calls is executed across microservices. This usually means a developer must add some code to instrument an application for this purpose. Often, instrumentation code is simply meant to send collected data such as traces and metrics to observability tools or services that can help store, visualize and analyze all this information.
+This can be particularly challenging for a distributed system comprised of multiple microservices, where a flow made of several calls may start in one microservice and continue in another. 
 
-Having to maintain this code, which is not part of the core logic of the application, is a burden on the developer, sometimes requiring understanding the observability tools' APIs, using additional SDKs etc. This instrumentation may also add to the portability challenges of an application, which may require different instrumentation depending on where the application is deployed. For example, different cloud providers offer different observability tools and an on-premises deployment might require a self-hosted solution.
+Observability into your application is critical in production environments, and can be useful during development to:
+- Understand bottlenecks
+- Improve performance
+- Perform basic debugging across the span of microservices
+
+While some data points about an application can be gathered from the underlying infrastructure (memory consumption, CPU usage), other meaningful information must be collected from an "application-aware" layer – one that can show how an important series of calls is executed across microservices. Typically, you'd add some code to instrument an application, which simply sends collected data (such as traces and metrics) to observability tools or services that can help store, visualize, and analyze all this information.
+
+Maintaining this instrumentation code, which is not part of the core logic of the application, requires understanding the observability tools' APIs, using additional SDKs, etc. This instrumentation may also present portability challenges for your application, requiring different instrumentation depending on where the application is deployed. For example:
+- Different cloud providers offer different observability tools
+- An on-premises deployment might require a self-hosted solution
 
 ## Observability for your application with Dapr
 
-When building an application which leverages Dapr API building blocks to perform service-to-service calls and pub/sub messaging, Dapr offers an advantage with respect to [distributed tracing]({{<ref tracing>}}). Because 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 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.
 
 ### Distributed tracing
 
-Dapr can be [configured to emit tracing data]({{<ref setup-tracing.md>}}), and because Dapr does so using the widely adopted protocols of [Open Telemetry (OTEL)](https://opentelemetry.io/) and [Zipkin](https://zipkin.io), it can be easily integrated with multiple observability tools.
+Dapr can be [configured to emit tracing data]({{< ref setup-tracing.md >}}) using the widely adopted protocols of [Open Telemetry (OTEL)](https://opentelemetry.io/) and [Zipkin](https://zipkin.io). This makes it easily integrated with multiple observability tools.
 
 <img src="/images/observability-tracing.png" width=1000 alt="Distributed tracing with Dapr">
 
 ### 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 [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.
 
 ## Observability for the Dapr sidecar and control plane
 
-You also want to be able to observe Dapr itself, by collecting metrics on performance, throughput and latency and logs emitted by the Dapr sidecar, as well as the Dapr control plane services. Dapr sidecars have a health endpoint that can be probed to indicate their health status.
+You can also observe Dapr itself, by:
+- Generating logs emitted by the Dapr sidecar and the Dapr control plane services
+- Collecting metrics on performance, throughput, and latency
+- Using health endpoints probes to indicate the Dapr sidecar health status
 
 <img src="/images/observability-sidecar.png" width=1000 alt="Dapr sidecar metrics, logs and health checks">
 
 ### Logging
 
-Dapr generates [logs]({{<ref "logs.md">}}) to provide visibility into sidecar operation and to help users identify issues and perform debugging. Log events contain warning, error, info, and debug messages produced by Dapr system services. Dapr can also be configured to send logs to collectors such as [Fluentd]({{< ref fluentd.md >}}), [Azure Monitor]({{< ref azure-monitor.md >}}), and other observability tools, so that logs can be searched and analyzed to provide insights.
+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.
 
 ### Metrics
 
-Metrics are the series of measured values and counts that are collected and stored over time. [Dapr metrics]({{<ref "metrics">}}) provide monitoring capabilities to understand the behavior of the Dapr sidecar and control plane. For example, the metrics between a Dapr sidecar and the user application show call latency, traffic failures, error rates of requests, etc. Dapr [control plane metrics](https://github.com/dapr/dapr/blob/master/docs/development/dapr-metrics.md) show sidecar injection failures and the health of control plane services, including CPU usage, number of actor placements made, etc.
+Metrics are a series of measured values and counts collected and stored over time. [Dapr metrics]({{< ref metrics >}}) provide monitoring capabilities to understand the behavior of the Dapr sidecar and control plane. For example, the metrics between a Dapr sidecar and the user application show call latency, traffic failures, error rates of requests, etc. 
+
+Dapr [control plane metrics](https://github.com/dapr/dapr/blob/master/docs/development/dapr-metrics.md) show sidecar injection failures and the health of control plane services, including CPU usage, number of actor placements made, etc.
 
 ### Health checks
 
-The Dapr sidecar exposes an HTTP endpoint for [health checks]({{<ref sidecar-health.md>}}). With this API, user code or hosting environments can probe the Dapr sidecar to determine its status and identify issues with sidecar readiness.
+The Dapr sidecar exposes an HTTP endpoint for [health checks]({{< ref sidecar-health.md >}}). With this API, user code or hosting environments can probe the Dapr sidecar to determine its status and identify issues with sidecar readiness.
+
+Conversely, Dapr can be configured to probe for the [health of your application]({{< ref app-health.md >}}), and react to changes in the app's health, including stopping pub/sub subscriptions and short-circuiting service invocation calls.
+
+## Next steps
 
-Conversely, Dapr can be configured to probe for the [health of your application]({{<ref app-health.md >}}), and react to changes in the app's health, including stopping pub/sub subscriptions and short-circuiting service invocation calls.
+- [Learn more about observability in developing with Dapr]({{< ref develop-tracing >}})
+- [Learn more about observability in operating with Dapr]({{< ref tracing >}})

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

@@ -8,4 +8,5 @@ description: "Dapr capabilities that solve common development challenges for dis
 
 Get a high-level [overview of Dapr building blocks]({{< ref building-blocks-concept >}}) in the **Concepts** section.
 
-<img src="/images/buildingblocks-overview.png" alt="Diagram showing the different Dapr API building blocks" width=1000>
+<img src="/images/buildingblocks-overview.png" alt="Diagram showing the different Dapr API building blocks" width=1000>
+

daprdocs/content/en/developing-applications/building-blocks/actors/_index.md

@@ -5,3 +5,10 @@ linkTitle: "Actors"
 weight: 50
 description: Encapsulate code and data in reusable actor objects as a common microservices design pattern
 ---
+
+{{% alert title="More about Dapr Actors" color="primary" %}}
+ Learn more about how to use Dapr Actors:
+ - Try the [Actors quickstart]({{< ref actors-quickstart.md >}}).
+ - Explore actors via any of the [Dapr SDKs]({{< ref sdks >}}). 
+ - Review the [Actors API reference documentation]({{< ref actors_api.md >}}).
+{{% /alert %}}

daprdocs/content/en/developing-applications/building-blocks/bindings/_index.md

@@ -5,3 +5,12 @@ linkTitle: "Bindings"
 weight: 40
 description: Interface with or be triggered from external systems
 ---
+
+
+{{% alert title="More about Dapr Bindings" color="primary" %}}
+ Learn more about how to use Dapr Bindings:
+ - Try the [Bindings quickstart]({{< ref bindings-quickstart.md >}}).
+ - Explore input and output bindings via any of the supporting [Dapr SDKs]({{< ref sdks >}}). 
+ - Review the [Bindings API reference documentation]({{< ref bindings_api.md >}}).
+ - Browse the supported [input and output bindings component specs]({{< ref supported-bindings >}}).
+{{% /alert %}}

daprdocs/content/en/developing-applications/building-blocks/configuration/_index.md

@@ -5,3 +5,11 @@ linkTitle: "Configuration"
 weight: 80
 description: Manage and be notified of application configuration changes
 ---
+
+{{% alert title="More about Dapr Configuration" color="primary" %}}
+ Learn more about how to use Dapr Configuration:
+ - Try the [Configuration quickstart]({{< ref configuration-quickstart.md >}}).
+ - Explore configuration via any of the supporting [Dapr SDKs]({{< ref sdks >}}). 
+ - Review the [Configuration API reference documentation]({{< ref configuration_api.md >}}).
+ - Browse the supported [configuration component specs]({{< ref supported-configuration-stores >}}).
+{{% /alert %}}

daprdocs/content/en/developing-applications/building-blocks/cryptography/_index.md

@@ -4,4 +4,11 @@ title: "Cryptography"
 linkTitle: "Cryptography"
 weight: 110
 description: "Perform cryptographic operations without exposing keys to your application"  
----
+---
+
+{{% alert title="More about Dapr Cryptography" color="primary" %}}
+ Learn more about how to use Dapr Cryptography:
+ - Try the [Cryptography quickstart]({{< ref cryptography-quickstart.md >}}).
+ - Explore cryptography via any of the supporting [Dapr SDKs]({{< ref sdks >}}). 
+ - Browse the supported [cryptography component specs]({{< ref supported-cryptography >}}).
+{{% /alert %}}

daprdocs/content/en/developing-applications/building-blocks/distributed-lock/_index.md

@@ -5,3 +5,10 @@ linkTitle: "Distributed lock"
 weight: 90
 description: Distributed locks provide mutually exclusive access to shared resources from an application.
 ---
+
+{{% alert title="More about Dapr Distributed Lock" color="primary" %}}
+ Learn more about how to use Dapr Distributed Lock:
+ - Explore distributed locks via any of the supporting [Dapr SDKs]({{< ref sdks >}}). 
+ - Review the [Distributed Lock API reference documentation]({{< ref distributed_lock_api.md >}}).
+ - Browse the supported [distributed locks component specs]({{< ref supported-locks >}}).
+{{% /alert %}}

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

@@ -6,4 +6,10 @@ weight: 60
 description: See and measure the message calls to components and between networked services
 ---
 
-This section includes guides for developers in the context of observability. See other sections for a [general overview of the observability concept]({{< ref observability-concept >}}) in Dapr and for [operations guidance on monitoring]({{< ref monitoring >}}).
+{{% alert title="More about Dapr Observability" color="primary" %}}
+ Learn more about how to use Dapr Observability Lock:
+ - 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 %}}