@azure/mcp-linux-arm64 2.0.0-beta.8 → 2.0.0

package/dist/Instrumentation/Resources/api-reference/dotnet/WithMetrics.md

@@ -0,0 +1,105 @@
+---
+title: WithMetrics
+category: api-reference
+applies-to: 1.x
+---
+
+# .WithMetrics()
+
+## API surface
+
+| Method | Purpose |
+| --- | --- |
+| `.WithMetrics()` | Enable metrics with no additional configuration |
+| `.WithMetrics(Action<MeterProviderBuilder>)` | Enable metrics and configure the `MeterProviderBuilder` |
+| `builder.AddMeter(params string[] names)` | Subscribe to one or more `Meter` names |
+| `builder.AddReader(MetricReader)` | Add a metric reader instance |
+| `builder.AddReader<T>()` | Add a reader resolved from DI (registered as singleton) |
+| `builder.AddReader(Func<IServiceProvider, MetricReader>)` | Add a reader via factory |
+| `builder.AddView(string instrumentName, string name)` | Rename a metric stream (no wildcards) |
+| `builder.AddView(string instrumentName, MetricStreamConfiguration)` | Customize aggregation for an instrument (wildcards allowed) |
+| `builder.AddView(Func<Instrument, MetricStreamConfiguration?>)` | Programmatic view selection |
+| `builder.SetMaxMetricStreams(int)` | Set max metric streams (default: 1000) |
+| `builder.SetExemplarFilter(ExemplarFilterType)` | Set exemplar filter (`AlwaysOff`, `AlwaysOn`, `TraceBased`) |
+
+See also: ConfigureResource.md for resource configuration
+
+## When to use
+
+- Enable metrics collection in an ASP.NET Core or Worker Service app via `AddOpenTelemetry()`.
+- Enable metrics in a standalone/console app via `OpenTelemetrySdk.Create()`.
+- Subscribe to `Meter` names from your application code or instrumentation libraries.
+- Configure views to customize aggregation, rename streams, or set cardinality limits.
+- Call multiple times safely — only one `MeterProvider` is created per `IServiceCollection`.
+
+## Minimal example
+
+```csharp
+using OpenTelemetry;
+using OpenTelemetry.Metrics;
+
+var builder = WebApplication.CreateBuilder(args);
+
+builder.Services.AddOpenTelemetry()
+    .WithMetrics(metrics => metrics
+        .AddMeter("MyApp")
+        .AddOtlpExporter());
+
+var app = builder.Build();
+app.Run();
+```
+
+## Full example
+
+```csharp
+using OpenTelemetry;
+using OpenTelemetry.Metrics;
+using OpenTelemetry.Resources;
+
+var builder = WebApplication.CreateBuilder(args);
+
+builder.Services.AddOpenTelemetry()
+    .ConfigureResource(r => r.AddService("order-api"))
+    .WithMetrics(metrics => metrics
+        .AddMeter("OrderService", "PaymentService")
+        .AddAspNetCoreInstrumentation()
+        .AddHttpClientInstrumentation()
+        .AddView("request-duration", new ExplicitBucketHistogramConfiguration
+        {
+            Boundaries = new double[] { 0.01, 0.05, 0.1, 0.5, 1, 5, 10 }
+        })
+        .SetMaxMetricStreams(500)
+        .SetExemplarFilter(ExemplarFilterType.TraceBased)
+        .AddOtlpExporter());
+
+var app = builder.Build();
+app.Run();
+```
+
+### Standalone (non-host) usage
+
+```csharp
+using OpenTelemetry;
+using OpenTelemetry.Metrics;
+
+using var sdk = OpenTelemetrySdk.Create(builder => builder
+    .WithMetrics(metrics => metrics
+        .AddMeter("MyConsoleApp")
+        .AddOtlpExporter()));
+```
+
+## Key parameters
+
+| Parameter | Type | Default | Description |
+| --- | --- | --- | --- |
+| `maxMetricStreams` | `int` | 1000 | Maximum number of metric streams allowed (min: 1) |
+| `exemplarFilter` | `ExemplarFilterType` | `AlwaysOff` | Controls how measurements are offered to exemplar reservoirs |
+
+## Behavior notes
+
+- `AddMeter()` accepts exact `Meter` names — unregistered meters are ignored.
+- `AddView()` with a wildcard (`*`) in `instrumentName` cannot rename a stream (would cause conflicts).
+- Views are applied in registration order. The first matching view wins per instrument.
+- `SetMaxMetricPointsPerMetricStream()` is obsolete since 1.10.0 — use `MetricStreamConfiguration.CardinalityLimit` via `AddView` instead.
+- `WithMetrics()` automatically registers an `IMetricsListener` named `"OpenTelemetry"` to bridge `System.Diagnostics.Metrics`.
+- When used with `AddOpenTelemetry()`, the host manages `MeterProvider` lifecycle — do **not** call `Dispose()` manually.

package/dist/Instrumentation/Resources/api-reference/dotnet/WithTracing.md

@@ -0,0 +1,91 @@
+---
+title: WithTracing
+category: api-reference
+applies-to: 1.x
+---
+
+# .WithTracing()
+
+## API surface
+
+| Method | Purpose |
+| --- | --- |
+| `.WithTracing()` | Enable tracing with no additional configuration |
+| `.WithTracing(Action<TracerProviderBuilder>)` | Enable tracing and configure the `TracerProviderBuilder` |
+| `builder.AddSource(params string[] names)` | Subscribe to one or more `ActivitySource` names |
+| `builder.AddInstrumentation<T>()` | Add an instrumentation library via DI |
+| `builder.AddProcessor(BaseProcessor<Activity>)` | Add an activity processor instance |
+| `builder.AddProcessor<T>()` | Add a processor resolved from DI (registered as singleton) |
+| `builder.AddProcessor(Func<IServiceProvider, BaseProcessor<Activity>>)` | Add a processor via factory |
+| `builder.SetErrorStatusOnException(bool)` | Auto-set `Status.Error` on unhandled exceptions (default `true`) |
+
+See also: Sampling.md for `SetSampler()` overloads · ConfigureResource.md for resource configuration
+
+## When to use
+
+- Enable distributed tracing in an ASP.NET Core or Worker Service app via `AddOpenTelemetry()`.
+- Enable tracing in a standalone/console app via `OpenTelemetrySdk.Create()`.
+- Subscribe to `ActivitySource` names so the SDK captures spans from your code or instrumentation libraries.
+- Attach processors (e.g., `BatchActivityExportProcessor`) or set a custom sampler.
+- Call multiple times safely — only one `TracerProvider` is created per `IServiceCollection`.
+
+## Minimal example
+
+```csharp
+using OpenTelemetry;
+using OpenTelemetry.Trace;
+
+var builder = WebApplication.CreateBuilder(args);
+
+builder.Services.AddOpenTelemetry()
+    .WithTracing(tracing => tracing
+        .AddSource("MyApp")
+        .AddOtlpExporter());
+
+var app = builder.Build();
+app.Run();
+```
+
+## Full example
+
+```csharp
+using OpenTelemetry;
+using OpenTelemetry.Resources;
+using OpenTelemetry.Trace;
+
+var builder = WebApplication.CreateBuilder(args);
+
+builder.Services.AddOpenTelemetry()
+    .ConfigureResource(r => r.AddService("order-api"))
+    .WithTracing(tracing => tracing
+        .AddSource("OrderService", "PaymentService")
+        .AddAspNetCoreInstrumentation()
+        .AddHttpClientInstrumentation()
+        .SetSampler(new ParentBasedSampler(new TraceIdRatioBasedSampler(0.5)))
+        .AddProcessor<MyFilteringProcessor>()
+        .AddOtlpExporter());
+
+var app = builder.Build();
+app.Run();
+```
+
+### Standalone (non-host) usage
+
+```csharp
+using OpenTelemetry;
+using OpenTelemetry.Trace;
+
+using var sdk = OpenTelemetrySdk.Create(builder => builder
+    .WithTracing(tracing => tracing
+        .AddSource("MyConsoleApp")
+        .AddOtlpExporter()));
+
+// sdk.TracerProvider is available if needed
+```
+
+## Behavior notes
+
+- `AddSource()` accepts wildcard-free `ActivitySource` names. Activities from unregistered sources are dropped.
+- Processors run in registration order. Export processors should be added last.
+- When used with `AddOpenTelemetry()`, the host manages `TracerProvider` lifecycle — do **not** call `Dispose()` manually.
+- When used with `OpenTelemetrySdk.Create()`, you own the `OpenTelemetrySdk` instance and must dispose it.

package/dist/Instrumentation/Resources/concepts/dotnet/appinsights-aspnetcore.md

@@ -0,0 +1,113 @@
+---
+title: Application Insights for ASP.NET Core
+category: concept
+applies-to: 3.x
+---
+
+# Application Insights for ASP.NET Core
+
+**Category:** Concept
+**Applies to:** 3.x
+
+## Overview
+
+The `Microsoft.ApplicationInsights.AspNetCore` package provides built-in telemetry collection for ASP.NET Core applications, sending data to Azure Application Insights.
+
+## What It Provides
+
+One line of code enables full observability:
+
+```csharp
+builder.Services.AddApplicationInsightsTelemetry();
+```
+
+### Automatic Collection
+- **Requests** — All incoming HTTP requests with timing, status codes, and URLs
+- **Dependencies** — Outgoing HTTP calls, SQL queries, and Azure SDK calls
+- **Exceptions** — Unhandled exceptions with full stack traces
+- **Performance Counters** — CPU, memory, GC, and thread pool metrics
+- **Logs** — ILogger output (Information level and above by default)
+
+### Built-in Features
+- **Live Metrics** — Real-time monitoring via QuickPulse
+- **Adaptive Sampling** — Automatic volume control (configurable via `TracesPerSecond`)
+- **JavaScript Snippet** — Browser-side telemetry injection for Razor pages
+- **AAD Authentication** — Token-based auth via `TokenCredential`
+
+## Quick Start
+
+### 1. Install Package
+
+```bash
+dotnet add package Microsoft.ApplicationInsights.AspNetCore
+```
+
+### 2. Add to Program.cs
+
+```csharp
+var builder = WebApplication.CreateBuilder(args);
+builder.Services.AddApplicationInsightsTelemetry();
+var app = builder.Build();
+```
+
+### 3. Configure Connection String
+
+**Environment variable (recommended):**
+```bash
+APPLICATIONINSIGHTS_CONNECTION_STRING=InstrumentationKey=xxx;IngestionEndpoint=https://...
+```
+
+**Or in appsettings.json:**
+```json
+{
+  "ApplicationInsights": {
+    "ConnectionString": "InstrumentationKey=xxx;IngestionEndpoint=https://..."
+  }
+}
+```
+
+## Configuration Options
+
+Use `ApplicationInsightsServiceOptions` to customize behavior:
+
+```csharp
+builder.Services.AddApplicationInsightsTelemetry(options =>
+{
+    options.ConnectionString = "InstrumentationKey=...;IngestionEndpoint=...";
+    options.EnableQuickPulseMetricStream = true;
+    options.SamplingRatio = 0.5f;   // Collect 50% of telemetry
+});
+```
+
+| Property | Default | Description |
+|----------|---------|-------------|
+| `ConnectionString` | `null` | Application Insights connection string |
+| `Credential` | `null` | AAD `TokenCredential` for token-based auth |
+| `EnableQuickPulseMetricStream` | `true` | Enables Live Metrics |
+| `EnableDependencyTrackingTelemetryModule` | `true` | Tracks HTTP/SQL dependencies |
+| `EnableRequestTrackingTelemetryModule` | `true` | Tracks incoming requests |
+| `TracesPerSecond` | `5` | Rate-limited sampling target |
+| `SamplingRatio` | `null` | Fixed-rate sampling (0.0–1.0); overrides `TracesPerSecond` |
+
+## Connection String Resolution Order
+
+1. `ApplicationInsightsServiceOptions.ConnectionString` (code)
+2. Environment variable `APPLICATIONINSIGHTS_CONNECTION_STRING`
+3. Config key `ApplicationInsights:ConnectionString`
+
+## Extending with OpenTelemetry
+
+Application Insights 3.x is built on OpenTelemetry. You can add additional sources:
+
+```csharp
+builder.Services.AddApplicationInsightsTelemetry();
+builder.Services.AddOpenTelemetry()
+    .WithTracing(t => t.AddSource("MyApp.CustomSource"))
+    .WithMetrics(m => m.AddMeter("MyApp.CustomMeter"));
+```
+
+## See Also
+
+- AddApplicationInsightsTelemetry API (see in AddApplicationInsightsTelemetry.md)
+- ASP.NET Core Setup Example (see in aspnetcore-setup.md)
+- App Insights 2.x to 3.x Migration (see in appinsights-2x-to-3x-code-migration.md)

package/dist/Instrumentation/Resources/concepts/dotnet/aspnet-classic-appinsights.md

@@ -0,0 +1,95 @@
+---
+title: Application Insights for Classic ASP.NET
+category: concepts
+applies-to: dotnet-framework
+---
+
+# Application Insights for Classic ASP.NET
+
+## Overview
+
+Classic ASP.NET applications (.NET Framework 4.6.2+) use `Microsoft.ApplicationInsights.Web` for automatic request, dependency, and exception tracking. In 3.x, the package is built on OpenTelemetry internally.
+
+## How it works
+
+1. **NuGet package install** creates `ApplicationInsights.config` and registers HTTP modules in `Web.config`
+2. **`ApplicationInsightsHttpModule`** runs on every request — reads config, initializes `TelemetryConfiguration`, sets up the OpenTelemetry pipeline
+3. **`TelemetryHttpModule`** (from `OpenTelemetry.Instrumentation.AspNet`) captures request spans via `System.Diagnostics.Activity`
+4. **No code changes needed** — request tracking, dependency tracking, and exception tracking are automatic
+
+## Key configuration files
+
+| File | Purpose |
+|---|---|
+| `ApplicationInsights.config` | Connection string, sampling, feature flags |
+| `Web.config` | HTTP module registration (auto-configured by NuGet) |
+
+## ApplicationInsights.config (3.x format)
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<ApplicationInsights xmlns="http://schemas.microsoft.com/ApplicationInsights/2013/Settings">
+  <ConnectionString>InstrumentationKey=...;IngestionEndpoint=https://...</ConnectionString>
+  <TracesPerSecond>5.0</TracesPerSecond>
+  <EnableTraceBasedLogsSampler>true</EnableTraceBasedLogsSampler>
+  <EnableQuickPulseMetricStream>true</EnableQuickPulseMetricStream>
+  <EnablePerformanceCounterCollectionModule>true</EnablePerformanceCounterCollectionModule>
+  <EnableDependencyTrackingTelemetryModule>true</EnableDependencyTrackingTelemetryModule>
+  <EnableRequestTrackingTelemetryModule>true</EnableRequestTrackingTelemetryModule>
+  <AddAutoCollectedMetricExtractor>true</AddAutoCollectedMetricExtractor>
+</ApplicationInsights>
+```
+
+## Web.config HTTP modules (auto-configured)
+
+```xml
+<system.webServer>
+  <modules>
+    <add name="ApplicationInsightsWebTracking"
+         type="Microsoft.ApplicationInsights.Web.ApplicationInsightsHttpModule, Microsoft.AI.Web"
+         preCondition="managedHandler" />
+    <add name="TelemetryHttpModule"
+         type="OpenTelemetry.Instrumentation.AspNet.TelemetryHttpModule, OpenTelemetry.Instrumentation.AspNet.TelemetryHttpModule"
+         preCondition="integratedMode,managedHandler" />
+  </modules>
+</system.webServer>
+```
+
+## Extensibility — Custom processors
+
+Use `TelemetryConfiguration.ConfigureOpenTelemetryBuilder` in `Global.asax.cs`:
+
+```csharp
+using Microsoft.ApplicationInsights.Extensibility;
+using OpenTelemetry.Trace;
+using OpenTelemetry.Resources;
+
+protected void Application_Start()
+{
+    var config = TelemetryConfiguration.CreateDefault();
+    config.ConnectionString = "InstrumentationKey=...;IngestionEndpoint=...";
+    config.ConfigureOpenTelemetryBuilder(otel =>
+    {
+        otel.WithTracing(tracing => tracing.AddProcessor<MyCustomProcessor>());
+        otel.ConfigureResource(r => r.AddService("MyServiceName"));
+    });
+
+    AreaRegistration.RegisterAllAreas();
+    RouteConfig.RegisterRoutes(RouteTable.Routes);
+}
+```
+
+## Requirements
+
+- .NET Framework **4.6.2** or later (3.x raised minimum from 4.5.2)
+- IIS or IIS Express
+- `Microsoft.ApplicationInsights.Web` 3.x NuGet package
+
+## What's automatic (no code needed)
+
+- HTTP request tracking (all incoming requests)
+- SQL dependency tracking
+- HTTP dependency tracking (outgoing `HttpClient` / `WebRequest` calls)
+- Exception tracking
+- Performance counter collection
+- Live Metrics (Quick Pulse)

package/dist/Instrumentation/Resources/concepts/dotnet/azure-monitor-distro.md

@@ -0,0 +1,102 @@
+---
+title: Azure Monitor OpenTelemetry Distro
+category: concept
+applies-to: 3.x
+---
+
+# Azure Monitor OpenTelemetry Distro
+
+**Category:** Concept  
+**Applies to:** 3.x
+
+## Overview
+
+The Azure Monitor OpenTelemetry Distro (`Azure.Monitor.OpenTelemetry.AspNetCore`) is a batteries-included package that configures OpenTelemetry with sensible defaults for Azure Monitor/Application Insights.
+
+## What It Provides
+
+One line of code enables:
+
+```csharp
+builder.Services.AddOpenTelemetry().UseAzureMonitor();
+```
+
+### Automatic Instrumentation
+- **ASP.NET Core** - HTTP requests (traces)
+- **HttpClient** - Outgoing HTTP calls (dependencies)
+- **SQL Client** - Database calls
+- **Azure SDK** - Azure service calls
+
+### Automatic Export
+- Traces → Application Insights (requests, dependencies)
+- Metrics → Application Insights (performance counters, custom metrics)
+- Logs → Application Insights (traces, exceptions)
+
+### Automatic Enrichment
+- Cloud role name detection
+- Kubernetes metadata
+- Azure App Service metadata
+
+## Configuration
+
+### Connection String (Required)
+
+Option 1: Environment variable (recommended)
+```bash
+APPLICATIONINSIGHTS_CONNECTION_STRING=InstrumentationKey=xxx;IngestionEndpoint=https://...
+```
+
+Option 2: appsettings.json
+```json
+{
+  "AzureMonitor": {
+    "ConnectionString": "InstrumentationKey=xxx;IngestionEndpoint=https://..."
+  }
+}
+```
+
+Option 3: Code
+```csharp
+builder.Services.AddOpenTelemetry().UseAzureMonitor(options =>
+{
+    options.ConnectionString = "InstrumentationKey=xxx;...";
+});
+```
+
+### Optional Configuration
+
+```csharp
+builder.Services.AddOpenTelemetry().UseAzureMonitor(options =>
+{
+    // Sampling
+    options.SamplingRatio = 0.1f; // 10% sampling
+    
+    // Disable specific auto-instrumentation
+    options.EnableLiveMetrics = false;
+    
+    // Custom resource attributes
+    options.Resource = ResourceBuilder.CreateDefault()
+        .AddService("MyService", "1.0.0");
+});
+```
+
+## Package Reference
+
+```xml
+<PackageReference Include="Azure.Monitor.OpenTelemetry.AspNetCore" Version="1.3.0" />
+```
+
+## When to Use
+
+| Scenario | Recommendation |
+|----------|----------------|
+| New ASP.NET Core app | ✅ Use Distro |
+| Existing AI SDK 2.x app | ✅ Migrate to Distro |
+| Need custom exporters | Consider manual OpenTelemetry setup |
+| Non-ASP.NET Core | Use `Azure.Monitor.OpenTelemetry.Exporter` directly |
+
+## See Also
+
+- OpenTelemetry Pipeline(see in opentelemetry-pipeline.md)
+- UseAzureMonitor API(see in api-reference/dotnet/UseAzureMonitor.md)
+- Basic Setup Example(see in examples/dotnet/aspnetcore-distro-setup.md)

package/dist/Instrumentation/Resources/concepts/dotnet/opentelemetry-pipeline.md

@@ -0,0 +1,57 @@
+---
+title: OpenTelemetry Pipeline
+category: concept
+applies-to: 3.x
+---
+
+# OpenTelemetry Pipeline
+
+**Category:** Concept  
+**Applies to:** 3.x
+
+## Overview
+
+The OpenTelemetry pipeline is the data flow path for telemetry signals (traces, metrics, logs) from your application to observability backends. Understanding this pipeline is essential for Azure Monitor integration.
+
+## Pipeline Components
+
+```
+┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
+│  Instrumentation │ ──▶ │   Processors    │ ──▶ │    Exporters    │
+│  (Sources)       │     │   (Transform)   │     │   (Backends)    │
+└─────────────────┘     └─────────────────┘     └─────────────────┘
+```
+
+### 1. Instrumentation (Sources)
+- **ActivitySource** - Creates spans/traces
+- **Meter** - Creates metrics
+- **ILogger** - Creates logs (via OpenTelemetry.Extensions.Logging)
+
+### 2. Processors (Transform)
+- **BaseProcessor<Activity>** - Enrich or filter spans
+- **BaseProcessor<LogRecord>** - Enrich or filter logs
+- Run in pipeline order before export
+
+### 3. Exporters (Backends)
+- **Azure Monitor Exporter** - Sends to Application Insights
+- **OTLP Exporter** - Sends to any OTLP-compatible backend
+- **Console Exporter** - Debug output
+
+## Wiring Up the Pipeline
+
+See the AddOpenTelemetry API reference(see in AddOpenTelemetry.md) for full setup examples showing how sources, processors, and exporters are composed via the builder API.
+
+## Key Differences from Application Insights 2.x
+
+| 2.x Concept | 3.x Equivalent |
+|-------------|----------------|
+| TelemetryClient | ActivitySource / Meter / ILogger |
+| ITelemetryInitializer | BaseProcessor<Activity>.OnStart |
+| ITelemetryProcessor | BaseProcessor<Activity>.OnEnd |
+| TelemetryChannel | Exporter |
+| TelemetryConfiguration | OpenTelemetryBuilder |
+
+## See Also
+
+- Application Insights for ASP.NET Core(see in appinsights-aspnetcore.md)
+- AddOpenTelemetry API(see in AddOpenTelemetry.md)

package/dist/Instrumentation/Resources/concepts/nodejs/azure-monitor-overview.md

@@ -0,0 +1,106 @@
+# Azure Monitor for Node.js
+
+Azure Monitor OpenTelemetry for Node.js provides automatic instrumentation and telemetry collection for Node.js applications.
+
+## Key Features
+
+- **Automatic Instrumentation**: Captures HTTP requests, database calls, and external dependencies
+- **Custom Telemetry**: Track custom events, metrics, and traces
+- **Performance Monitoring**: Monitor response times, throughput, and failures
+- **Dependency Tracking**: Understand outgoing calls to databases, APIs, and services
+- **Distributed Tracing**: Follow requests across microservices
+
+## Supported Frameworks
+
+- Express.js
+- Next.js (via instrumentation hook — requires webpack externals configuration)
+- Fastify
+- NestJS
+- Koa
+- Hapi
+- And many more through OpenTelemetry auto-instrumentation
+
+> **Note**: Next.js requires special setup due to its webpack bundling. See the Next.js Setup Guide(see in basic-setup-nextjs.md) for details on externalizing server-only packages.
+
+## Installation
+
+```bash
+npm install @azure/monitor-opentelemetry
+```
+
+## Basic Setup
+
+```javascript
+const { useAzureMonitor } = require('@azure/monitor-opentelemetry');
+
+// Enable Azure Monitor at startup
+useAzureMonitor({
+  azureMonitorExporterOptions: {
+    connectionString: process.env.APPLICATIONINSIGHTS_CONNECTION_STRING
+  }
+});
+
+// Your application code follows...
+const express = require('express');
+const app = express();
+```
+
+## Configuration Options
+
+The `useAzureMonitor()` function accepts configuration for:
+- Connection string
+- Sampling rate
+- Custom resource attributes
+- Instrumentation configuration
+- Logging options
+
+## What Gets Instrumented
+
+### Automatically Captured
+- HTTP/HTTPS requests and responses
+- Database queries (MongoDB, MySQL, PostgreSQL, etc.)
+- Redis operations
+- External HTTP calls
+- Exceptions and errors
+
+### Custom Telemetry
+```javascript
+const { trace } = require('@opentelemetry/api');
+
+// Get current span
+const span = trace.getActiveSpan();
+span?.setAttribute('custom.attribute', 'value');
+
+// Log custom events
+console.log('Custom event logged'); // Captured as trace
+```
+
+## Best Practices
+
+1. **Initialize Early**: Call `useAzureMonitor()` before loading other modules
+2. **Use Environment Variables**: Store connection string in `.env` file
+3. **Enable Sampling**: For high-traffic apps, configure sampling to manage costs
+4. **Add Context**: Use custom attributes to enrich telemetry
+5. **Monitor Performance**: Set up alerts in Azure Monitor for key metrics
+
+## Connection String
+
+Get your connection string from Azure Portal:
+1. Navigate to your Application Insights resource
+2. Go to "Overview" section
+3. Copy the "Connection String" value
+
+Set it as an environment variable:
+```bash
+export APPLICATIONINSIGHTS_CONNECTION_STRING="InstrumentationKey=..."
+```
+
+Or in `.env` file:
+```
+APPLICATIONINSIGHTS_CONNECTION_STRING=InstrumentationKey=...
+```
+
+## Links
+
+- [Azure Monitor OpenTelemetry for Node.js Documentation](https://learn.microsoft.com/azure/azure-monitor/app/opentelemetry-enable?tabs=nodejs)
+- [OpenTelemetry for Node.js](https://opentelemetry.io/docs/instrumentation/js/)