ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-02-15 02:48:30 -05:00
Code Issues Packages Projects Releases Wiki Activity

Switch schema-compare to using ads common events (#8957)

Browse Source 
* Switch schema-compare to using ads common events

* Update yarn.lock
This commit is contained in:
Charles Gagnon
2020-01-24 15:30:31 -08:00
committed by GitHub
parent f49fe59e1f
commit 379eae22ed
5 changed files with 103 additions and 174 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
extensions/schema-compare/src/dialogs/schemaCompareDialog.ts
View File

@@ -8,7 +8,7 @@ import * as azdata from 'azdata';
import * as vscode from 'vscode';
import { SchemaCompareMainWindow } from '../schemaCompareMainWindow';
import { promises as fs } from 'fs';
import { Telemetry } from '../telemetry';
import { TelemetryReporter, TelemetryViews } from '../telemetry';
import { getEndpointName, getRootPath } from '../utils';
import * as mssql from '../../../mssql';
@@ -152,10 +152,11 @@ export class SchemaCompareDialog {
};
}
Telemetry.sendTelemetryEvent('SchemaCompareStart', {
'sourceIsDacpac': this.sourceIsDacpac.toString(),
'targetIsDacpac': this.targetIsDacpac.toString()
});
TelemetryReporter.createActionEvent(TelemetryViews.SchemaCompareDialog, 'SchemaCompareStart')
.withAdditionalProperties({
sourceIsDacpac: this.sourceIsDacpac.toString(),
targetIsDacpac: this.targetIsDacpac.toString()
}).send();
// update source and target values that are displayed
this.schemaCompareResult.updateSourceAndTarget();

142
extensions/schema-compare/src/schemaCompareMainWindow.ts
View File

@@ -10,7 +10,7 @@ import * as os from 'os';
import * as path from 'path';
import * as mssql from '../../mssql';
import { SchemaCompareOptionsDialog } from './dialogs/schemaCompareOptionsDialog';
import { Telemetry } from './telemetry';
import { TelemetryReporter, TelemetryViews } from './telemetry';
import { getTelemetryErrorType, getEndpointName, verifyConnectionAndGetOwnerUri, getRootPath } from './utils';
import { SchemaCompareDialog } from './dialogs/schemaCompareDialog';
import { isNullOrUndefined } from 'util';
@@ -281,7 +281,7 @@ export class SchemaCompareMainWindow {
}
public async execute(): Promise<void> {
Telemetry.sendTelemetryEvent('SchemaComparisonStarted');
TelemetryReporter.sendActionEvent(TelemetryViews.SchemaCompareMainWindow, 'SchemaComparisonStarted');
const service = await this.getService();
if (!this.operationId) {
// create once per page
@@ -289,17 +289,18 @@ export class SchemaCompareMainWindow {
}
this.comparisonResult = await service.schemaCompare(this.operationId, this.sourceEndpointInfo, this.targetEndpointInfo, azdata.TaskExecutionMode.execute, this.deploymentOptions);
if (!this.comparisonResult || !this.comparisonResult.success) {
Telemetry.sendTelemetryEventForError('SchemaComparisonFailed', {
'errorType': getTelemetryErrorType(this.comparisonResult.errorMessage),
'operationId': this.comparisonResult.operationId
});
TelemetryReporter.createErrorEvent(TelemetryViews.SchemaCompareMainWindow, 'SchemaComparisonFailed', undefined, getTelemetryErrorType(this.comparisonResult.errorMessage))
.withAdditionalProperties({
operationId: this.comparisonResult.operationId
}).send();
vscode.window.showErrorMessage(localize('schemaCompare.compareErrorMessage', "Schema Compare failed: {0}", this.comparisonResult.errorMessage ? this.comparisonResult.errorMessage : 'Unknown'));
return;
}
Telemetry.sendTelemetryEvent('SchemaComparisonFinished', {
'endTime': Date.now().toString(),
'operationId': this.comparisonResult.operationId
});
TelemetryReporter.createActionEvent(TelemetryViews.SchemaCompareMainWindow, 'SchemaComparisonFinished')
.withAdditionalProperties({
'endTime': Date.now().toString(),
'operationId': this.comparisonResult.operationId
}).send();
let data = this.getAllDifferences(this.comparisonResult.differences);
@@ -642,10 +643,11 @@ export class SchemaCompareMainWindow {
private async cancelCompare() {
Telemetry.sendTelemetryEvent('SchemaCompareCancelStarted', {
'startTime:': Date.now().toString(),
'operationId': this.operationId
});
TelemetryReporter.createActionEvent(TelemetryViews.SchemaCompareMainWindow, 'SchemaCompareCancelStarted')
.withAdditionalProperties({
'startTime': Date.now().toString(),
'operationId': this.operationId
}).send();
// clean the pane
this.flexModel.removeItem(this.loader);
@@ -659,17 +661,18 @@ export class SchemaCompareMainWindow {
const result = await service.schemaCompareCancel(this.operationId);
if (!result || !result.success) {
Telemetry.sendTelemetryEvent('SchemaCompareCancelFailed', {
'errorType': getTelemetryErrorType(result.errorMessage),
'operationId': this.operationId
});
TelemetryReporter.createErrorEvent(TelemetryViews.SchemaCompareMainWindow, 'SchemaCompareCancelFailed', undefined, getTelemetryErrorType(result.errorMessage))
.withAdditionalProperties({
'operationId': this.operationId
}).send();
vscode.window.showErrorMessage(
localize('schemaCompare.cancelErrorMessage', "Cancel schema compare failed: '{0}'", (result && result.errorMessage) ? result.errorMessage : 'Unknown'));
}
Telemetry.sendTelemetryEvent('SchemaCompareCancelEnded', {
'endTime:': Date.now().toString(),
'operationId': this.operationId
});
TelemetryReporter.createActionEvent(TelemetryViews.SchemaCompareMainWindow, 'SchemaCompareCancelEnded')
.withAdditionalProperties({
'endTime': Date.now().toString(),
'operationId': this.operationId
}).send();
}
}
@@ -683,24 +686,26 @@ export class SchemaCompareMainWindow {
}).component();
this.generateScriptButton.onDidClick(async (click) => {
Telemetry.sendTelemetryEvent('SchemaCompareGenerateScriptStarted', {
'startTime:': Date.now().toString(),
'operationId': this.comparisonResult.operationId
});
TelemetryReporter.createActionEvent(TelemetryViews.SchemaCompareMainWindow, 'SchemaCompareGenerateScriptStarted')
.withAdditionalProperties({
'startTime': Date.now().toString(),
'operationId': this.comparisonResult.operationId
}).send();
const service = await this.getService();
const result = await service.schemaCompareGenerateScript(this.comparisonResult.operationId, this.targetEndpointInfo.serverName, this.targetEndpointInfo.databaseName, azdata.TaskExecutionMode.script);
if (!result || !result.success) {
Telemetry.sendTelemetryEvent('SchemaCompareGenerateScriptFailed', {
'errorType': getTelemetryErrorType(result.errorMessage),
'operationId': this.comparisonResult.operationId
});
TelemetryReporter.createErrorEvent(TelemetryViews.SchemaCompareMainWindow, 'SchemaCompareGenerateScriptFailed', undefined, getTelemetryErrorType(result.errorMessage))
.withAdditionalProperties({
'operationId': this.comparisonResult.operationId
}).send();
vscode.window.showErrorMessage(
localize('schemaCompare.generateScriptErrorMessage', "Generate script failed: '{0}'", (result && result.errorMessage) ? result.errorMessage : 'Unknown'));
}
Telemetry.sendTelemetryEvent('SchemaCompareGenerateScriptEnded', {
'endTime:': Date.now().toString(),
'operationId': this.comparisonResult.operationId
});
TelemetryReporter.createActionEvent(TelemetryViews.SchemaCompareMainWindow, 'SchemaCompareGenerateScriptEnded')
.withAdditionalProperties({
'endTime': Date.now().toString(),
'operationId': this.comparisonResult.operationId
}).send();
});
}
@@ -715,8 +720,7 @@ export class SchemaCompareMainWindow {
}).component();
this.optionsButton.onDidClick(async (click) => {
Telemetry.sendTelemetryEvent('SchemaCompareOptionsOpened');
TelemetryReporter.sendActionEvent(TelemetryViews.SchemaCompareMainWindow, 'SchemaCompareOptionsOpened');
// create fresh every time
this.schemaCompareOptionDialog = new SchemaCompareOptionsDialog(this.deploymentOptions, this);
await this.schemaCompareOptionDialog.openDialog();
@@ -739,10 +743,11 @@ export class SchemaCompareMainWindow {
vscode.window.showWarningMessage(applyConfirmation, { modal: true }, yesString).then(async (result) => {
if (result === yesString) {
Telemetry.sendTelemetryEvent('SchemaCompareApplyStarted', {
'startTime': Date.now().toString(),
'operationId': this.comparisonResult.operationId
});
TelemetryReporter.createActionEvent(TelemetryViews.SchemaCompareMainWindow, 'SchemaCompareApplyStarted')
.withAdditionalProperties({
'startTime': Date.now().toString(),
'operationId': this.comparisonResult.operationId
}).send();
// disable apply and generate script buttons because the results are no longer valid after applying the changes
this.setButtonsForRecompare();
@@ -750,10 +755,10 @@ export class SchemaCompareMainWindow {
const service = await this.getService();
const result = await service.schemaComparePublishChanges(this.comparisonResult.operationId, this.targetEndpointInfo.serverName, this.targetEndpointInfo.databaseName, azdata.TaskExecutionMode.execute);
if (!result || !result.success) {
Telemetry.sendTelemetryEvent('SchemaCompareApplyFailed', {
'errorType': getTelemetryErrorType(result.errorMessage),
'operationId': this.comparisonResult.operationId
});
TelemetryReporter.createErrorEvent(TelemetryViews.SchemaCompareMainWindow, 'SchemaCompareApplyFailed', undefined, getTelemetryErrorType(result.errorMessage))
.withAdditionalProperties({
'operationId': this.comparisonResult.operationId
}).send();
vscode.window.showErrorMessage(
localize('schemaCompare.updateErrorMessage', "Schema Compare Apply failed '{0}'", result.errorMessage ? result.errorMessage : 'Unknown'));
@@ -763,10 +768,11 @@ export class SchemaCompareMainWindow {
this.applyButton.enabled = true;
this.applyButton.title = applyEnabledMessage;
}
Telemetry.sendTelemetryEvent('SchemaCompareApplyEnded', {
'endTime': Date.now().toString(),
'operationId': this.comparisonResult.operationId
});
TelemetryReporter.createActionEvent(TelemetryViews.SchemaCompareMainWindow, 'SchemaCompareApplyEnded')
.withAdditionalProperties({
'endTime': Date.now().toString(),
'operationId': this.comparisonResult.operationId
}).send();
}
});
});
@@ -841,8 +847,7 @@ export class SchemaCompareMainWindow {
}).component();
this.switchButton.onDidClick(async (click) => {
Telemetry.sendTelemetryEvent('SchemaCompareSwitch');
TelemetryReporter.sendActionEvent(TelemetryViews.SchemaCompareMainWindow, 'SchemaCompareSwitch');
// switch source and target
[this.sourceEndpointInfo, this.targetEndpointInfo] = [this.targetEndpointInfo, this.sourceEndpointInfo];
[this.sourceName, this.targetName] = [this.targetName, this.sourceName];
@@ -885,7 +890,7 @@ export class SchemaCompareMainWindow {
}).component();
this.selectSourceButton.onDidClick(() => {
Telemetry.sendTelemetryEvent('SchemaCompareSelectSource');
TelemetryReporter.sendActionEvent(TelemetryViews.SchemaCompareMainWindow, 'SchemaCompareSelectSource');
let dialog = new SchemaCompareDialog(this);
dialog.openDialog();
});
@@ -897,7 +902,7 @@ export class SchemaCompareMainWindow {
}).component();
this.selectTargetButton.onDidClick(() => {
Telemetry.sendTelemetryEvent('SchemaCompareSelectTarget');
TelemetryReporter.sendActionEvent(TelemetryViews.SchemaCompareMainWindow, 'SchemaCompareSelectTarget');
let dialog = new SchemaCompareDialog(this);
dialog.openDialog();
});
@@ -914,7 +919,7 @@ export class SchemaCompareMainWindow {
}).component();
this.openScmpButton.onDidClick(async (click) => {
Telemetry.sendTelemetryEvent('SchemaCompareOpenScmpStarted');
TelemetryReporter.sendActionEvent(TelemetryViews.SchemaCompareMainWindow, 'SchemaCompareOpenScmpStarted');
const rootPath = getRootPath();
let fileUris = await vscode.window.showOpenDialog(
{
@@ -938,9 +943,7 @@ export class SchemaCompareMainWindow {
let startTime = Date.now();
const result = await service.schemaCompareOpenScmp(fileUri.fsPath);
if (!result || !result.success) {
Telemetry.sendTelemetryEvent('SchemaCompareOpenScmpFailed', {
'errorType': getTelemetryErrorType(result.errorMessage)
});
TelemetryReporter.sendErrorEvent(TelemetryViews.SchemaCompareMainWindow, 'SchemaCompareOpenScmpFailed', undefined, getTelemetryErrorType(result.errorMessage));
vscode.window.showErrorMessage(
localize('schemaCompare.openScmpErrorMessage', "Open scmp failed: '{0}'", (result && result.errorMessage) ? result.errorMessage : 'Unknown'));
return;
@@ -958,9 +961,10 @@ export class SchemaCompareMainWindow {
// clear out any old results
this.resetForNewCompare();
Telemetry.sendTelemetryEvent('SchemaCompareOpenScmpEnded', {
'elapsedTime:': (Date.now() - startTime).toString()
});
TelemetryReporter.createActionEvent(TelemetryViews.SchemaCompareMainWindow, 'SchemaCompareOpenScmpEnded')
.withAdditionalProperties({
elapsedTime: (Date.now() - startTime).toString()
}).send();
});
}
@@ -1021,22 +1025,22 @@ export class SchemaCompareMainWindow {
let targetExcludes: mssql.SchemaCompareObjectId[] = this.convertExcludesToObjectIds(this.originalTargetExcludes);
let startTime = Date.now();
Telemetry.sendTelemetryEvent('SchemaCompareSaveScmp');
TelemetryReporter.sendActionEvent(TelemetryViews.SchemaCompareMainWindow, 'SchemaCompareSaveScmp');
const service = await this.getService();
const result = await service.schemaCompareSaveScmp(this.sourceEndpointInfo, this.targetEndpointInfo, azdata.TaskExecutionMode.execute, this.deploymentOptions, filePath.fsPath, sourceExcludes, targetExcludes);
if (!result || !result.success) {
Telemetry.sendTelemetryEvent('SchemaCompareSaveScmpFailed', {
'errorType': getTelemetryErrorType(result.errorMessage),
'operationId': this.comparisonResult.operationId
});
TelemetryReporter.createErrorEvent(TelemetryViews.SchemaCompareMainWindow, 'SchemaCompareSaveScmpFailed', undefined, getTelemetryErrorType(result.errorMessage))
.withAdditionalProperties({
operationId: this.comparisonResult.operationId
}).send();
vscode.window.showErrorMessage(
localize('schemaCompare.saveScmpErrorMessage', "Save scmp failed: '{0}'", (result && result.errorMessage) ? result.errorMessage : 'Unknown'));
}
Telemetry.sendTelemetryEvent('SchemaCompareSaveScmpEnded', {
'elapsedTime:': (Date.now() - startTime).toString(),
'operationId': this.comparisonResult.operationId
});
TelemetryReporter.createActionEvent(TelemetryViews.SchemaCompareMainWindow, 'SchemaCompareSaveScmpEnded')
.withAdditionalProperties({
elapsedTime: (Date.now() - startTime).toString(),
operationId: this.comparisonResult.operationId
});
});
}

98
extensions/schema-compare/src/telemetry.ts
View File

@@ -3,99 +3,17 @@
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as vscode from 'vscode';
import TelemetryReporter from 'vscode-extension-telemetry';
import AdsTelemetryReporter from 'ads-extension-telemetry';
import * as Utils from './utils';
const packageJson = require('../package.json');
export interface ITelemetryEventProperties {
[key: string]: string;
let packageInfo = Utils.getPackageInfo(packageJson);
export const TelemetryReporter = new AdsTelemetryReporter(packageInfo.name, packageInfo.version, packageInfo.aiKey);
export enum TelemetryViews {
SchemaCompareMainWindow = 'SchemaCompareMainWindow',
SchemaCompareDialog = 'SchemaCompareDialog'
}
export interface ITelemetryEventMeasures {
[key: string]: number;
}
/**
* Filters error paths to only include source files. Exported to support testing
*/
export function filterErrorPath(line: string): string {
if (line) {
let values: string[] = line.split('/out/');
if (values.length <= 1) {
// Didn't match expected format
return line;
} else {
return values[1];
}
}
}
export class Telemetry {
private static reporter: TelemetryReporter;
private static disabled: boolean;
/**
* Disable telemetry reporting
*/
public static disable(): void {
this.disabled = true;
}
/**
* Initialize the telemetry reporter for use.
*/
public static initialize(): void {
if (typeof this.reporter === 'undefined') {
// Check if the user has opted out of telemetry
if (!vscode.workspace.getConfiguration('telemetry').get<boolean>('enableTelemetry', true)) {
this.disable();
return;
}
let packageInfo = Utils.getPackageInfo(packageJson);
this.reporter = new TelemetryReporter(packageInfo.name, packageInfo.version, packageInfo.aiKey);
}
}
/**
* Send a telemetry event for a general error
* @param err The error to log
*/
public static sendTelemetryEventForError(err: string, properties?: ITelemetryEventProperties): void {
this.sendTelemetryEvent('Error', { error: err, ...properties });
}
/**
* Send a telemetry event using application insights
*/
public static sendTelemetryEvent(
eventName: string,
properties?: ITelemetryEventProperties,
measures?: ITelemetryEventMeasures): void {
if (typeof this.disabled === 'undefined') {
this.disabled = false;
}
if (this.disabled || typeof (this.reporter) === 'undefined') {
// Don't do anything if telemetry is disabled
return;
}
if (!properties || typeof properties === 'undefined') {
properties = {};
}
try {
this.reporter.sendTelemetryEvent(eventName, properties, measures);
} catch (telemetryErr) {
// If sending telemetry event fails ignore it so it won't break the extension
console.error('Failed to send telemetry event. error: ' + telemetryErr);
}
}
}
Telemetry.initialize();