# Set up Application Insights for distributed tracing Dapr integrates with Application Insights through OpenTelemetry's default exporter along with a dedicated agent known as the [Local Forwarder](https://docs.microsoft.com/en-us/azure/azure-monitor/app/opencensus-local-forwarder). > Note: The local forwarder is still under preview, but being deprecated. The Application Insights team recommends using [Opentelemetry collector](https://github.com/open-telemetry/opentelemetry-collector) (which is in alpha state) for the future so we're working on moving from local forwarder to [Opentelemetry collector](https://github.com/open-telemetry/opentelemetry-collector). - [How to configure distributed tracing with Application insights](#How-to-configure-distributed-tracing-with-Application-insights) - [Tracing configuration](#Tracing-configuration) ## How to configure distributed tracing with Application insights The following steps show you how to configure Dapr to send distributed tracing data to Application insights. ### Setup Application Insights 1. First, you'll need an Azure account. Please see instructions [here](https://azure.microsoft.com/free/) to apply for a **free** Azure account. 2. Follow instructions [here](https://docs.microsoft.com/en-us/azure/azure-monitor/app/create-new-resource) to create a new Application Insights resource. 3. Get Application insights Intrumentation key from your application insights page 4. On the Application Insights side menu, go to `Configure -> API Access` 5. Click `Create API Key` 6. Select all checkboxes under `Choose what this API key will allow apps to do:` - Read telemetry - Write annotations - Authenticate SDK control channel 7. Generate Key and get API key ### Setup the Local Forwarder #### Self hosted environment This is for running the local forwarder on your machine. 1. Run the local fowarder ```bash docker run -e APPINSIGHTS_INSTRUMENTATIONKEY= -e APPINSIGHTS_LIVEMETRICSSTREAMAUTHENTICATIONAPIKEY= -d -p 55678:55678 daprio/dapr-localforwarder:latest ``` > Note: [dapr-localforwarder](https://github.com/dapr/ApplicationInsights-LocalForwarder) is the forked version of [ApplicationInsights Localforwarder](https://github.com/microsoft/ApplicationInsights-LocalForwarder/), that includes the minor changes for Dapr. We're working on migrating to [opentelemetry-sdk and opentelemetry collector](https://opentelemetry.io/). 1. Create the following YAML files. Copy the native.yaml component file and tracing.yaml configuration file to the *components/* sub-folder under the same folder where you run your application. * native.yaml component ```yaml apiVersion: dapr.io/v1alpha1 kind: Component metadata: name: native namespace: default spec: type: exporters.native metadata: - name: enabled value: "true" - name: agentEndpoint value: "localhost:55678" ``` * tracing.yaml configuration ```yaml apiVersion: dapr.io/v1alpha1 kind: Configuration metadata: name: tracing namespace: default spec: tracing: samplingRate: "1" ``` 3. When running in the local self hosted mode, you need to launch Dapr with the `--config` parameter: ```bash dapr run --app-id mynode --app-port 3000 --config ./components/tracing.yaml node app.js ``` #### Kubernetes environment 1. Download [dapr-localforwarder.yaml](./localforwarder/dapr-localforwarder.yaml) 2. Replace `` with your Instrumentation Key and `` with the generated key in the file ```yaml - name: APPINSIGHTS_INSTRUMENTATIONKEY value: # Replace with your ikey - name: APPINSIGHTS_LIVEMETRICSSTREAMAUTHENTICATIONAPIKEY value: # Replace with your generated api key ``` 3. Deploy dapr-localfowarder.yaml ```bash kubectl apply -f ./dapr-localforwarder.yaml ``` 4. Create the following YAML files * native.yaml component ```yaml apiVersion: dapr.io/v1alpha1 kind: Component metadata: name: native namespace: default spec: type: exporters.native metadata: - name: enabled value: "true" - name: agentEndpoint value: "" ``` * tracing.yaml configuration ```yaml apiVersion: dapr.io/v1alpha1 kind: Configuration metadata: name: tracing namespace: default spec: tracing: samplingRate: "1" ``` 5. Use kubectl to apply the above CRD files: ```bash kubectl apply -f tracing.yaml kubectl apply -f native.yaml ``` 6. Deploy your app with tracing When running in Kubernetes mode, apply the configuration by adding a `dapr.io/config` annotation to the container that you want to participate in the distributed tracing, as shown in the following example: ```yaml apiVersion: apps/v1 kind: Deployment metadata: ... spec: ... template: metadata: ... annotations: dapr.io/enabled: "true" dapr.io/id: "calculator-front-end" dapr.io/port: "8080" dapr.io/config: "tracing" ``` That's it! There's no need include any SDKs or instrument your application code. Dapr automatically handles the distributed tracing for you. > **NOTE**: You can register multiple exporters at the same time, and the tracing logs are forwarded to all registered exporters. Deploy and run some applications. After a few minutes, you should see tracing logs appearing in your Application Insights resource. You can also use **Application Map** to examine the topology of your services, as shown below: ![Application map](../../images/azure-monitor.png) > **NOTE**: Only operations going through Dapr API exposed by Dapr sidecar (e.g. service invocation or event publishing) will be displayed in Application Map topology. Direct service invocations (not going through the Dapr API) will not be shown. ## Tracing configuration The `tracing` section under the `Configuration` spec contains the following properties: ```yml tracing: samplingRate: "1" ``` The following table lists the different properties. Property | Type | Description ---- | ------- | ----------- samplingRate | string | Set sampling rate for tracing to be enabled or disabled. `samplingRate` is used to enable or disable the tracing. To disable the sampling rate , set `samplingRate : "0"` in the configuration. The valid range of samplingRate is between 0 and 1 inclusive. The sampling rate determines whether a trace span should be sampled or not based on value. `samplingRate : "1"` will always sample the traces.By default, the sampling rate is 1 in 10,000 ## References * [How-To: Use W3C Trace Context for distributed tracing](../../howto/use-w3c-tracecontext/readme.md)