Update docs with event-driven telemetry

Author: yasithrashan

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 vscode-telemetry
+Copyright (c) 2025 vscode-extension-telemetry
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,200 +1,91 @@
 # VSCode Telemetry Extension
 
-A Visual Studio Code extension demonstrating telemetry tracking using Azure Application Insights via the `vscode-extension-telemetry` package. Features a clean, reusable architecture with helper functions for easy telemetry integration.
+A Visual Studio Code extension demonstrating telemetry tracking using Azure Application Insights with an event-driven architecture.
 
 ## Features
 
-- **Reusable Telemetry Utilities** - Factory functions and helpers for consistent telemetry tracking
-- **Rich Event Data** - Track custom properties and performance measurements
-- **Component-based Tracking** - Organize telemetry by component for better insights
-- **Azure Application Insights Integration** - Direct connection to Azure monitoring
-- **Performance Metrics** - Built-in execution time and memory usage tracking
+- Event-driven telemetry using `TelemetryEventEmitter`
+- Clean, reusable API for tracking events
+- Component-based organization
+- Azure Application Insights integration
 
 ## Setup
 
-### Prerequisites
-
-- Visual Studio Code ^1.105.0
-- Node.js 22.x
-- Azure Application Insights connection string
-
-### Installation
-
-1. Clone this repository
-2. Install dependencies:
+1. Clone and install dependencies:
    ```bash
    npm install
    ```
-3. Configure your Application Insights connection string in `src/extension.ts`:
+
+2. Add your Application Insights connection string in [src/extension.ts](src/extension.ts):
    ```typescript
    const connectionString = 'your-connection-string-here';
    ```
-4. Compile the extension:
+
+3. Run the extension:
    ```bash
    npm run compile
+   # Press F5 to debug
    ```
-5. Press `F5` to run the extension in debug mode
 
 ## Usage
 
-### Commands
-
-- **Hello World** (`extension.helloWorld`) - Demo command that sends telemetry with performance metrics
-
-Access via Command Palette (`Cmd+Shift+P` / `Ctrl+Shift+P`)
-
-### API Reference
-
-#### `createTelemetryReporter(context: ExtensionContext): TelemetryReporter`
-
-Factory function to create and initialize a telemetry reporter instance.
+### Sending Telemetry Events
 
-**Parameters:**
-- `context` - VSCode extension context for lifecycle management
+Use the `TelemetryEventEmitter` to fire events from anywhere in your extension:
 
-**Returns:** Configured TelemetryReporter instance
-
-**Example:**
 ```typescript
-export function activate(context: vscode.ExtensionContext) {
-    const reporter = createTelemetryReporter(context);
-    // Use reporter for telemetry tracking
-}
-```
-
-#### `sendTelemetryEvent(reporter, eventName, componentName, customDimensions?, measurements?)`
-
-Helper function to send telemetry events with standardized structure.
-
-**Parameters:**
-- `reporter` - TelemetryReporter instance
-- `eventName` - Name of the event to track
-- `componentName` - Component that triggered the event
-- `customDimensions` - Optional object with custom string properties
-- `measurements` - Optional object with numeric measurements
-
-**Example:**
-```typescript
-sendTelemetryEvent(
-    reporter,
-    'helloWorldCommand',
-    'commandPalette',
-    {
-        source: 'command',
-        userId: '123456',
-        userName: 'yasithrashan'
-    },
-    {
-        'performance.executionTime': Date.now(),
-        'performance.memoryUsed': process.memoryUsage().heapUsed
-    }
-);
-```
+import { TelemetryEventEmitter } from './event-emitter';
 
-### Telemetry Events
-
-The extension tracks:
-- `helloWorldCommand` - Fired when the Hello World command is executed
-  - Dimensions: source, userId, userName, component
-  - Measurements: performance.executionTime, performance.memoryUsed
-
-### Adding Custom Telemetry
-
-1. Get the reporter instance (created during activation)
-2. Call `sendTelemetryEvent()` with your event data:
-
-```typescript
-sendTelemetryEvent(
-    reporter,
-    'myCustomEvent',
-    'myComponent',
-    {
+TelemetryEventEmitter.instance.fire({
+    eventName: 'myEvent',
+    componentName: 'myComponent',
+    customDimensions: {
         action: 'buttonClick',
         feature: 'newFeature'
     },
-    {
-        'response.time': responseTime,
-        'data.size': dataSize
+    measurements: {
+        executionTime: 123,
+        memoryUsed: 456789
     }
-);
+});
 ```
 
-## Architecture
-
-### Core Components
+### API Reference
 
-#### `createTelemetryReporter()`
-Factory function that encapsulates TelemetryReporter initialization and lifecycle management. Automatically registers the reporter for disposal when the extension deactivates.
+#### `TelemetryEventEmitter`
 
-#### `sendTelemetryEvent()`
-Standardized telemetry helper that:
-- Adds component tracking to all events
-- Merges custom dimensions with standard properties
-- Ensures consistent event structure across the extension
-- Supports both properties (strings) and measurements (numbers)
+Singleton event emitter for telemetry events.
 
-### Telemetry Data Structure
+**Methods:**
+- `fire(payload)` - Fire a telemetry event
+- `onDidFire(listener)` - Listen for telemetry events
 
-Each event includes:
+#### `createTelemetryReporter(context)`
 
-**Standard Properties:**
-- `component` - Component name (e.g., 'commandPalette', 'sidebar', 'webview')
+Creates and initializes a telemetry reporter.
 
-**Custom Dimensions (strings):**
-- Any additional context properties you provide
-- Examples: userId, source, action, feature
+#### `sendTelemetryEvent(reporter, eventName, componentName, customDimensions?, measurements?)`
 
-**Measurements (numbers):**
-- Performance metrics
-- Usage statistics
-- Any numeric data points
+Sends a telemetry event to Application Insights.
 
-**Example Event Structure:**
-```json
-{
-    "eventName": "helloWorldCommand",
-    "properties": {
-        "component": "commandPalette",
-        "source": "command",
-        "userId": "123456",
-        "userName": "yasithrashan"
-    },
-    "measurements": {
-        "performance.executionTime": 1732435200000,
-        "performance.memoryUsed": 45678912
-    }
-}
+## Architecture
 
-## Development
+The extension uses an event-driven architecture:
 
-```bash
-# Compile TypeScript
-npm run compile
+1. Components fire telemetry events using `TelemetryEventEmitter`
+2. The extension listens for these events during activation
+3. Events are forwarded to Azure Application Insights via the reporter
 
-# Watch mode
-npm run watch
+This pattern decouples telemetry logic from business logic, making code cleaner and more maintainable.
 
-# Lint code
-npm run lint
+## Development
 
-# Package extension
-vsce package
+```bash
+npm run compile  # Compile TypeScript
+npm run watch    # Watch mode
+npm run lint     # Lint code
 ```
 
-## Dependencies
-
-- [vscode-extension-telemetry](https://www.npmjs.com/package/vscode-extension-telemetry) - Official telemetry library for VSCode extensions
-
 ## License
 
-MIT License - see [LICENSE](LICENSE) file for details.
-
-## Resources
-
-- [VSCode Extension Telemetry Guide](https://code.visualstudio.com/api/extension-guides/telemetry)
-- [Application Insights Documentation](https://docs.microsoft.com/en-us/azure/azure-monitor/app/app-insights-overview)
-- [vscode-extension-telemetry GitHub](https://github.com/Microsoft/vscode-extension-telemetry)
-
----
-
-**Happy tracking!**
+[MIT](LICENSE)