How to use vscode-extension-telemetry - 10 common examples

export function createTelemetryReporter(ctx: vscode.ExtensionContext): ITelemetryReporter {
    const { extensionName, extensionVersion, aiKey } = getPackageInfo(ctx);

    let newReporter: ITelemetryReporter;

    if (debugTelemetryEnabled) {
        console.warn(`${extensionName}: DEBUGTELEMETRY mode enabled (${debugTelemetryVerbose ? 'verbose' : 'quiet'}) - not sending telemetry`);
        newReporter = new DebugReporter(extensionName, extensionVersion, debugTelemetryVerbose);
    } else {
        const reporter: TelemetryReporter = new TelemetryReporter(extensionName, extensionVersion, aiKey);
        ctx.subscriptions.push(reporter);
        newReporter = reporter;
    }

    // Send an event with some general info
    newReporter.sendTelemetryEvent('info', {
        isActivationEvent: 'true',
        product: vscode.env.appName,
        language: vscode.env.language
    });

    return newReporter;
}

export function activate(context: vscode.ExtensionContext): void {
    // create telemetry reporter on extension activation
    telemetryReporter = new TelemetryReporter(PackageJSON.name, PackageJSON.version, AI_KEY);

    // If both extensions are enabled, this will cause unexpected behavior since both register the same commands
    if (PackageJSON.name.toLowerCase() === "powershell-preview"
        && vscode.extensions.getExtension("ms-vscode.powershell")) {
        vscode.window.showWarningMessage(
            "'PowerShell' and 'PowerShell Preview' are both enabled. Please disable one for best performance.");
    }

    checkForUpdatedVersion(context, PackageJSON.version);

    vscode.languages.setLanguageConfiguration(
        PowerShellLanguageId,
        {
            wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\=\+\[\{\]\}\\\|\;\'\"\,\.\<\>\/\?\s]+)/g,

            indentationRules: {

export function sendTelemetryEvent(eventName: string, properties?: {
    [key: string]: string;
}, measures?: {
    [key: string]: number;
}) {
    // Check out later (no idea why default import isn't being picked up)
    try {
        reporter = reporter ? reporter : new TelemetryReporter(extensionId, extensionVersion, aiKey);
    }
    catch (ex) {
        reporter = reporter ? reporter : new TelemetryReporter.default(extensionId, extensionVersion, aiKey);
    }

    try {
        reporter.sendTelemetryEvent.apply(reporter, arguments);
    }
    catch (ex) {

    }
}

static initialize(context: vscode.ExtensionContext): void {
    const packageInfo = getPackageInfo(context);
    if (!packageInfo) {
      console.log('Unable to initialize telemetry');
      return;
    }
    if (!packageInfo.aiKey) {
      console.log(
          'Unable to initialize telemetry, please make sure AIKey is set in package.json');
      return;
    }
    this._reporter = new TelemetryReporter(
        packageInfo.name, packageInfo.version, packageInfo.aiKey);
  }
}

constructor(options: any) {
        super({ ...options, context: null });
        this.name = "telemetry";
        if (!options.context) {
            winston.error("Failed to initialize telemetry, please set the vscode context in options.");
            return;
        }
        const packageInfo = getPackageInfo(options.context);
        if (!packageInfo.aiKey) {
            winston.error("Failed to initialize telemetry due to no aiKey in package.json.");
            return;
        }
        this.reporter = new TelemetryReporter(packageInfo.name, packageInfo.version, packageInfo.aiKey);
    }

constructor(ctx: vscode.ExtensionContext) {
        super(() => reporter.dispose());
        let packageInfo = getPackageInfo(ctx);
        if (packageInfo !== undefined && packageInfo.enableTelemetry) {
            reporter = new TelemetryReporter(packageInfo.name, packageInfo.version, packageInfo.aiKey);
        }
    }
}

private constructor() {
        this.telemetryReporter = new TelemetryReporter('IBMBlockchain.ibm-blockchain-platform', this.getVersion(), this.key);
    }

export function sendTelemetryEvent(eventName: string, properties?: {
	[key: string]: string;
}, measures?: {
	[key: string]: number;
}): void {

	let temp = vscode.extensions.getExtension(extensionId).packageJSON.contributes;
	telemtryReporter = telemtryReporter ? telemtryReporter : new TelemetryReporter(extensionId, extensionVersion, aiKey);
	telemtryReporter.sendTelemetryEvent(eventName, properties, measures);
}

export async function activate(context: vscode.ExtensionContext): Promise {

    const extensionId = CSharpExtensionId;
    const extension = vscode.extensions.getExtension(extensionId);
    const extensionVersion = extension.packageJSON.version;
    const aiKey = extension.packageJSON.contributes.debuggers[0].aiKey;
    const reporter = new TelemetryReporter(extensionId, extensionVersion, aiKey);

    util.setExtensionPath(extension.extensionPath);

    const eventStream = new EventStream();
    const optionStream = createOptionStream(vscode);
    let optionProvider = new OptionProvider(optionStream);

    let dotnetChannel = vscode.window.createOutputChannel('.NET');
    let dotnetChannelObserver = new DotNetChannelObserver(dotnetChannel);
    let dotnetLoggerObserver = new DotnetLoggerObserver(dotnetChannel);
    eventStream.subscribe(dotnetChannelObserver.post);
    eventStream.subscribe(dotnetLoggerObserver.post);

    let dotnetTestChannel = vscode.window.createOutputChannel(".NET Test Log");
    let dotnetTestChannelObserver = new DotNetTestChannelObserver(dotnetTestChannel);
    let dotnetTestLoggerObserver = new DotNetTestLoggerObserver(dotnetTestChannel);

constructor(context:vscode.ExtensionContext) {
        this.reporter = new TelemetryReporter(extensionId, extensionVersion, key);
        context.subscriptions.push(this.reporter);
    }