Using azure appinsights with operationalinsights

Question

Pulumi · Accepted Answer

To use Azure Application Insights and Operational Insights (Log Analytics) together in Pulumi, you first need to understand the purpose of both services:

- **Azure Application Insights**: A feature of Azure Monitor, is an extensible Application Performance Management (APM) service for developers and DevOps professionals. It monitors the performance and availability of your applications.

- **Azure Operational Insights (Log Analytics)**: A part of Azure Monitor, it collects telemetry from a variety of sources and uses the query language from Azure Data Explorer to retrieve and analyze data.

We'll set up a Pulumi program that provisions an instance of each service and configures them to work together. This setup can help monitor the performance metrics and log data from your applications.

Below is a Pulumi program in TypeScript demonstrating this setup. The program creates a workspace for Operational Insights and then an Application Insights component attached to the created workspace. Please make sure you have the prerequisites set, such as having Azure credentials configured for Pulumi.

```typescript
import * as pulumi from "@pulumi/pulumi";
import * as insights from "@pulumi/azure-native/operationalinsights";
import * as appinsights from "@pulumi/azure/appinsights";

// Declare the location for our resources.
const location = "West US";

// Create an instance of the Azure Operational Insights Workspace.
const workspace = new insights.Workspace("myWorkspace", {
    resourceGroupName: "myResourceGroup", // Replace with your resource group name
    location: location,
    // Additional properties such as retention can be configured here
});

// Create an Application Insights component linked to the Operational Insights workspace.
const appInsightsComponent = new appinsights.Insights("myAppInsights", {
    resourceGroupName: "myResourceGroup", // Replace with your resource group name
    location: location,
    workspaceId: workspace.id,
    applicationType: "web",
    // Application Insights specific configuration can go here
});

// Export the Application Insights Instrumentation Key
export const instrumentationKey = appInsightsComponent.instrumentationKey;
```

### How it Works:
1. **Import Modules**: We load the required Pulumi modules for Azure resources.
2. **Configure Location**: We specify the Azure region where we want our resources to be provisioned.
3. **Operational Insights Workspace Creation**: We create an Operational Insights workspace called `myWorkspace` within a specified resource group.
4. **Application Insights Component**: We then create an Application Insights instance called `myAppInsights`. We link it to the previously created workspace using `workspaceId: workspace.id`. The `applicationType` specifies the type of application we're monitoring, which in this case is a web application.
5. **Exports**: Expose the Application Insight's instrumentation key, which can be used by your applications to send telemetry data to Application Insights.

Remember to replace `"myResourceGroup"` with the actual name of your Azure Resource Group where the resources should be provisioned.

### Next Steps:
- Integrate the instrumentation key from Application Insights with your application to send telemetry data.
- Use Kusto Query Language (KQL) in Azure Operational Insights to analyze and get insights from the collected data.
- Configure alert rules and automation based on the analysis from Operational Insights.

To run this Pulumi program, you need to have Pulumi installed and configured for use with Azure. Then, after saving the above code into a file (e.g., `index.ts`), you can execute it using the Pulumi CLI commands:

```sh
pulumi stack init dev
pulumi up
```

This will set up a new Pulumi 'dev' stack and deploy the resources described in your TypeScript program. After deployment, the Application Insights instrumentation key will be outputted, which you can then use in your application code to start sending telemetry data.