Merge branch 'v1.11' into endgame_v1.11

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

@@ -137,7 +137,7 @@ Refer [api spec]({{< ref "actors_api.md#invoke-reminder" >}}) for more details.
 
 ## Error handling
 
-When an actor's method completes successfully, the runtime will contineu to invoke the method at the specified timer or reminder schedule. However, if the method throws an exception, the runtime catches it and logs the error message in the Dapr sidecar logs, without retrying. 
+When an actor's method completes successfully, the runtime will continue to invoke the method at the specified timer or reminder schedule. However, if the method throws an exception, the runtime catches it and logs the error message in the Dapr sidecar logs, without retrying. 
 
 To allow actors to recover from failures and retry after a crash or restart, you can persist an actor's state by configuring a state store, like Redis or Azure Cosmos DB. 
 

daprdocs/content/en/developing-applications/building-blocks/pubsub/pubsub-cloudevents.md

@@ -106,7 +106,7 @@ with DaprClient() as client:
     result = client.publish_event(
         pubsub_name='order_pub_sub',
         topic_name='orders',
-        publish_metadata={'cloudevent.id: 'd99b228f-6c73-4e78-8c4d-3f80a043d317', cloudevent.source: 'payment'}
+        publish_metadata={'cloudevent.id': 'd99b228f-6c73-4e78-8c4d-3f80a043d317', 'cloudevent.source': 'payment'}
     )
 ```
 

daprdocs/content/en/getting-started/quickstarts/pubsub-quickstart.md

@@ -235,7 +235,7 @@ Verify you have the following files included in the service directory:
 Run the `order-processor` subscriber service alongside a Dapr sidecar.
 
 ```bash
-dapr run --app-port 5001 --app-id order-processing --app-protocol http --dapr-http-port 3501 --resources-path ../../../components -- npm run start
+dapr run --app-port 5002 --app-id order-processing --app-protocol http --dapr-http-port 3501 --resources-path ../../../components -- npm run start
 ```
 
 In the `order-processor` subscriber, we're subscribing to the Redis instance called `orderpubsub` [(as defined in the `pubsub.yaml` component)]({{< ref "#pubsubyaml-component-file" >}}) and topic `orders`. This enables your app code to talk to the Redis component instance through the Dapr sidecar.
@@ -389,7 +389,7 @@ dotnet build
 Run the `order-processor` subscriber service alongside a Dapr sidecar.
 
 ```bash
-dapr run --app-id order-processor --resources-path ../../../components --app-port 7005 -- dotnet run
+dapr run --app-id order-processor --resources-path ../../../components --app-port 7006 -- dotnet run
 ```
 
 In the `order-processor` subscriber, we're subscribing to the Redis instance called `orderpubsub` [(as defined in the `pubsub.yaml` component)]({{< ref "#pubsubyaml-component-file" >}}) and topic `orders`. This enables your app code to talk to the Redis component instance through the Dapr sidecar.
@@ -706,7 +706,7 @@ go build .
 Run the `order-processor` subscriber service alongside a Dapr sidecar.
 
 ```bash
-dapr run --app-port 6002 --app-id order-processor-sdk --app-protocol http --dapr-http-port 3501 --resources-path ../../../components -- go run .
+dapr run --app-port 6005 --app-id order-processor-sdk --app-protocol http --dapr-http-port 3501 --resources-path ../../../components -- go run .
 ```
 
 In the `order-processor` subscriber, we're subscribing to the Redis instance called `orderpubsub` [(as defined in the `pubsub.yaml` component)]({{< ref "#pubsubyaml-component-file" >}}) and topic `orders`. This enables your app code to talk to the Redis component instance through the Dapr sidecar.

daprdocs/content/en/operations/observability/tracing/otel-collector/open-telemetry-collector-jaeger.md

@@ -0,0 +1,142 @@
+---
+type: docs
+title: "Using OpenTelemetry Collector to collect traces to send to Jaeger"
+linkTitle: "Using the OpenTelemetry for Jaeger"
+weight: 1200
+description: "How to push trace events to Jaeger distributed tracing platform, using the OpenTelemetry Collector."
+type: docs
+---
+
+While Dapr supports writing traces using OpenTelemetry (OTLP) and Zipkin protocols, Zipkin support for Jaeger has been deprecated in favor of OTLP. Although Jaeger supports OTLP directly, the recommended approach for production is to use the OpenTelemetry Collector to collect traces from Dapr and send them to Jaeger, allowing your application to quickly offload data and take advantage of features like retries, batching, and encryption. For more information, read the Open Telemetry Collector [documentation](https://opentelemetry.io/docs/collector/#when-to-use-a-collector).
+{{< tabs Self-hosted Kubernetes >}}
+
+{{% codetab %}}
+<!-- self-hosted -->
+## Configure Jaeger in self-hosted mode
+
+### Local setup
+
+The simplest way to start Jaeger is to run the pre-built, all-in-one Jaeger image published to DockerHub and expose the OTLP port:
+
+```bash
+docker run -d --name jaeger \
+  -p 4317:4317  \
+  -p 16686:16686 \
+  jaegertracing/all-in-one:1.49
+```
+
+Next, create the following `config.yaml` file locally:
+
+> **Note:** Because you are using the Open Telemetry protocol to talk to Jaeger, you need to fill out the `otel` section of the tracing configuration and set the `endpointAddress` to the address of the Jaeger container.
+
+```yaml
+apiVersion: dapr.io/v1alpha1
+kind: Configuration
+metadata:
+  name: tracing
+  namespace: default
+spec:
+  tracing:
+    samplingRate: "1"
+    stdout: true
+    otel:
+      endpointAddress: "localhost:4317"
+      isSecure: false
+      protocol: grpc 
+```
+
+To launch the application referring to the new YAML configuration file, use
+the `--config` option. For example:
+
+```bash
+dapr run --app-id myapp --app-port 3000 node app.js --config config.yaml
+```
+
+### View traces
+
+To view traces in your browser, go to `http://localhost:16686` to see the Jaeger UI.
+{{% /codetab %}}
+
+{{% codetab %}}
+<!-- kubernetes -->
+## Configure Jaeger on Kubernetes with the OpenTelemetry Collector
+
+The following steps show you how to configure Dapr to send distributed tracing data to the OpenTelemetry Collector which, in turn, sends the traces to Jaeger.
+
+### Prerequisites
+
+- [Install Dapr on Kubernetes]({{< ref kubernetes >}})
+- [Set up Jaeger](https://www.jaegertracing.io/docs/1.49/operator/) using the Jaeger Kubernetes Operator
+
+### Set up OpenTelemetry Collector to push to Jaeger
+
+To push traces to your Jaeger instance, install the OpenTelemetry Collector on your Kubernetes cluster.
+
+1. Download and inspect the [`open-telemetry-collector-jaeger.yaml`](/docs/open-telemetry-collector/open-telemetry-collector-jaeger.yaml) file.
+
+1. In the data section of the `otel-collector-conf` ConfigMap, update the `otlp/jaeger.endpoint` value to reflect the endpoint of your Jaeger collector Kubernetes service object.
+
+1. Deploy the OpenTelemetry Collector into the same namespace where your Dapr-enabled applications are running:
+
+   ```sh
+   kubectl apply -f open-telemetry-collector-jaeger.yaml
+   ```
+
+### Set up Dapr to send traces to OpenTelemetryCollector
+
+Create a Dapr configuration file to enable tracing and export the sidecar traces to the OpenTelemetry Collector.
+
+1. Use the [`collector-config-otel.yaml`](/docs/open-telemetry-collector/collector-config-otel.yaml) file to create your own Dapr configuration.
+
+1. Update the `namespace` and `otel.endpointAddress` values to align with the namespace where your Dapr-enabled applications and OpenTelemetry Collector are deployed.
+
+1. Apply the configuration with:
+
+   ```sh
+   kubectl apply -f collector-config.yaml
+   ```
+
+### Deploy your app with tracing enabled
+
+Apply the `tracing` Dapr configuration by adding a `dapr.io/config` annotation to the application deployment that you want to enable distributed tracing for, as shown in the following example:
+
+  ```yaml
+  apiVersion: apps/v1
+  kind: Deployment
+  metadata:
+    ...
+  spec:
+    ...
+    template:
+      metadata:
+        ...
+        annotations:
+          dapr.io/enabled: "true"
+          dapr.io/app-id: "MyApp"
+          dapr.io/app-port: "8080"
+          dapr.io/config: "tracing"
+  ```
+
+You can register multiple tracing exporters at the same time, and the tracing logs are forwarded to all registered exporters.
+
+That’s it! There’s no need to include the OpenTelemetry SDK or instrument your application code. Dapr automatically handles the distributed tracing for you.
+
+### View traces
+
+To view Dapr sidecar traces, port-forward the Jaeger Service and open the UI:
+
+```bash
+kubectl port-forward svc/jaeger-query 16686 -n observability
+```
+
+In your browser, go to `http://localhost:16686` and you will see the Jaeger UI.
+
+![jaeger](/images/jaeger_ui.png)
+{{% /codetab %}}
+
+{{< /tabs >}}
+## References
+
+- [Jaeger Getting Started](https://www.jaegertracing.io/docs/1.49/getting-started/)
+- [Jaeger Kubernetes Operator](https://www.jaegertracing.io/docs/1.49/operator/)
+- [OpenTelemetry Collector Exporters](https://opentelemetry.io/docs/collector/configuration/#exporters)

daprdocs/content/en/operations/observability/tracing/otel-collector/open-telemetry-collector.md

@@ -6,9 +6,9 @@ weight: 900
 description: "How to use Dapr to push trace events through the OpenTelemetry Collector."
 ---
 
-Dapr directly writes traces using the OpenTelemetry (OTEL) protocol as the **recommended** method. For observability tools that support OTEL protocol, it is recommended to use the OpenTelemetry Collector, as it allows your application to quickly offload data and includes features, such as retries, batching, and encryption. For more information, read the Open Telemetry [documentation](https://opentelemetry.io/docs/collector/#when-to-use-a-collector). 
+Dapr directly writes traces using the OpenTelemetry (OTLP) protocol as the **recommended** method. For observability tools that support the OTLP directly, it is recommended to use the [OpenTelemetry Collector](https://github.com/open-telemetry/opentelemetry-collector), as it allows your application to quickly offload data and includes features, such as retries, batching, and encryption. For more information, read the Open Telemetry Collector [documentation](https://opentelemetry.io/docs/collector/#when-to-use-a-collector).
 
-Dapr can also write traces using the Zipkin protocol. Previous to supporting the OTEL protocol, you use the Zipkin protocol with the [OpenTelemetry Collector](https://github.com/open-telemetry/opentelemetry-collector) to send traces to observability tools such as AWS X-Ray, Google Cloud Operations Suite, and Azure Monitor. Both protocol approaches are valid, however OTEL is the recommended choice.
+Dapr can also write traces using the Zipkin protocol. Prior to supporting the OTLP protocol, the Zipkin protocol was used with the OpenTelemetry Collector to send traces to observability tools such as AWS X-Ray, Google Cloud Operations Suite, and Azure Monitor. Both protocol approaches are valid, however the OpenTelemetry protocol is the recommended choice.
 
 ![Using OpenTelemetry Collect to integrate with many backend](/images/open-telemetry-collector.png)
 

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

@@ -75,6 +75,6 @@ turns on tracing for the sidecar.
 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 >}})
+- [Jaeger]({{< ref open-telemetry-collector-jaeger.md >}})
 - [Zipkin]({{< ref zipkin.md >}})
 - [Datadog]({{< ref datadog.md >}})