adopt new loader with 'onNodeCachedData', send telemetry for successful cached data generation

src/vs/code/electron-browser/sharedProcess.js

@@ -83,12 +83,10 @@ function main() {
 
 		window.MonacoEnvironment = {};
 
-		const nodeCachedDataErrors = window.MonacoEnvironment.nodeCachedDataErrors = [];
 		require.config({
 			baseUrl: rootUrl,
 			'vs/nls': nlsConfig,
 			nodeCachedDataDir: configuration.nodeCachedDataDir,
-			onNodeCachedDataError: function (err) { nodeCachedDataErrors.push(err) },
 			nodeModules: [/*BUILD->INSERT_NODE_MODULES*/]
 		});
 

src/vs/loader.js

@@ -253,15 +253,21 @@ var AMDLoader;
             if (typeof options.nodeCachedDataWriteDelay !== 'number' || options.nodeCachedDataWriteDelay < 0) {
                 options.nodeCachedDataWriteDelay = 1000 * 7;
             }
-            if (typeof options.onNodeCachedDataError !== 'function') {
-                options.onNodeCachedDataError = function (err) {
-                    if (err.errorCode === 'cachedDataRejected') {
+            if (typeof options.onNodeCachedData !== 'function') {
+                options.onNodeCachedData = function (err, data) {
+                    if (!err) {
+                        // ignore
+                    }
+                    else if (err.errorCode === 'cachedDataRejected') {
                         console.warn('Rejected cached data from file: ' + err.path);
                     }
                     else if (err.errorCode === 'unlink' || err.errorCode === 'writeFile') {
                         console.error('Problems writing cached data file: ' + err.path);
                         console.error(err.detail);
                     }
+                    else {
+                        console.error(err);
+                    }
                 };
             }
             return options;
@@ -742,31 +748,40 @@ var AMDLoader;
             var _this = this;
             if (script.cachedDataRejected) {
                 // data rejected => delete cache file
-                moduleManager.getConfig().getOptionsLiteral().onNodeCachedDataError({
+                moduleManager.getConfig().getOptionsLiteral().onNodeCachedData({
                     errorCode: 'cachedDataRejected',
                     path: cachedDataPath
                 });
-                NodeScriptLoader._runSoon(function () { return _this._fs.unlink(cachedDataPath, function (err) {
-                    if (err) {
-                        moduleManager.getConfig().getOptionsLiteral().onNodeCachedDataError({
-                            errorCode: 'unlink',
-                            path: cachedDataPath,
-                            detail: err
-                        });
-                    }
-                }); }, moduleManager.getConfig().getOptionsLiteral().nodeCachedDataWriteDelay);
+                NodeScriptLoader._runSoon(function () {
+                    return _this._fs.unlink(cachedDataPath, function (err) {
+                        if (err) {
+                            moduleManager.getConfig().getOptionsLiteral().onNodeCachedData({
+                                errorCode: 'unlink',
+                                path: cachedDataPath,
+                                detail: err
+                            });
+                        }
+                    });
+                }, moduleManager.getConfig().getOptionsLiteral().nodeCachedDataWriteDelay);
             }
             else if (script.cachedDataProduced) {
+                // data produced => tell outside world
+                moduleManager.getConfig().getOptionsLiteral().onNodeCachedData(undefined, {
+                    path: cachedDataPath,
+                    length: script.cachedData.length
+                });
                 // data produced => write cache file
-                NodeScriptLoader._runSoon(function () { return _this._fs.writeFile(cachedDataPath, script.cachedData, function (err) {
-                    if (err) {
-                        moduleManager.getConfig().getOptionsLiteral().onNodeCachedDataError({
-                            errorCode: 'writeFile',
-                            path: cachedDataPath,
-                            detail: err
-                        });
-                    }
-                }); }, moduleManager.getConfig().getOptionsLiteral().nodeCachedDataWriteDelay);
+                NodeScriptLoader._runSoon(function () {
+                    return _this._fs.writeFile(cachedDataPath, script.cachedData, function (err) {
+                        if (err) {
+                            moduleManager.getConfig().getOptionsLiteral().onNodeCachedData({
+                                errorCode: 'writeFile',
+                                path: cachedDataPath,
+                                detail: err
+                            });
+                        }
+                    });
+                }, moduleManager.getConfig().getOptionsLiteral().nodeCachedDataWriteDelay);
             }
         };
         NodeScriptLoader._runSoon = function (callback, minTimeout) {

src/vs/workbench/electron-browser/bootstrap/index.js

@@ -163,13 +163,13 @@ function main() {
 
 		window.MonacoEnvironment = {};
 
-		const nodeCachedDataErrors = window.MonacoEnvironment.nodeCachedDataErrors = [];
+		const onNodeCachedData = window.MonacoEnvironment.onNodeCachedData = [];
 		require.config({
 			baseUrl: rootUrl,
 			'vs/nls': nlsConfig,
 			recordStats: !!configuration.performance,
 			nodeCachedDataDir: configuration.nodeCachedDataDir,
-			onNodeCachedDataError: function (err) { nodeCachedDataErrors.push(err) },
+			onNodeCachedData: function () { onNodeCachedData.push(arguments) },
 			nodeModules: [/*BUILD->INSERT_NODE_MODULES*/]
 		});
 

src/vs/workbench/electron-browser/nodeCachedDataManager.ts

@@ -7,7 +7,7 @@
 import { IDisposable, dispose } from 'vs/base/common/lifecycle';
 import { onUnexpectedError } from 'vs/base/common/errors';
 import { TPromise } from 'vs/base/common/winjs.base';
-import { join } from 'path';
+import { join, basename } from 'path';
 import { readdir, rimraf, stat } from 'vs/base/node/pfs';
 import { IEnvironmentService } from 'vs/platform/environment/common/environment';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
@@ -26,7 +26,7 @@ export class NodeCachedDataManager {
 		this._telemetryService = telemetryService;
 		this._environmentService = environmentService;
 
-		this._handleCachedDataErrors();
+		this._handleCachedDataInfo();
 		this._manageCachedDataSoon();
 	}
 
@@ -34,20 +34,25 @@ export class NodeCachedDataManager {
 		this._disposables = dispose(this._disposables);
 	}
 
-	private _handleCachedDataErrors(): void {
-		const onNodeCachedDataError = (err) => {
-			this._telemetryService.publicLog('nodeCachedData', { errorCode: err.errorCode, path: err.path });
+	private _handleCachedDataInfo(): void {
+		const onNodeCachedData = (err, data) => {
+			console.log('onNodeCachedDatare', err, data);
+			if (err) {
+				this._telemetryService.publicLog('nodeCachedData', { errorCode: err.errorCode, path: basename(err.path) });
+			} else if (data) {
+				this._telemetryService.publicLog('nodeCachedDataProduced', { path: basename(data.path) });
+			}
 		};
 
 		// handle future and past errors
-		(<any>self).require.config({ onNodeCachedDataError });
-		(<any[]>(<any>window).MonacoEnvironment.nodeCachedDataErrors).forEach(onNodeCachedDataError);
-		delete (<any>window).MonacoEnvironment.nodeCachedDataErrors;
+		(<any>self).require.config({ onNodeCachedData });
+		delete (<any>window).MonacoEnvironment.onNodeCachedData;
+		(<any[]>(<any>window).MonacoEnvironment.onNodeCachedData).forEach(args => onNodeCachedData.apply(undefined, args));
 
 		// stop when being disposed
 		this._disposables.push({
 			dispose() {
-				(<any>self).require.config({ onNodeCachedDataError: undefined }, true);
+				(<any>self).require.config({ onNodeCachedData: undefined }, true);
 			}
 		});
 	}