Websites/perf.webkit.org/tools/detect-changes.js - WebKit - Git at Google

 #!/usr/local/bin/node

 var fs = require('fs');
 var http = require('http');
 var https = require('https');
 var data = require('../public/v2/data.js');
 var RunsData = data.RunsData;
 var Statistics = require('../public/shared/statistics.js');
 var StatisticsStrategies = require('../public/v2/statistics-strategies.js');
 var parseArguments = require('./js/parse-arguments.js').parseArguments;

 // FIXME: We shouldn't use a global variable like this.
 var settings;
 function main(argv)
 {
     var options = parseArguments(argv, [
         {name: '--server-config-json', required: true},
         {name: '--change-detection-config-json', required: true},
         {name: '--seconds-to-sleep', type: parseFloat, default: 1200},
     ]);
     if (!options)
         return;

     settings = JSON.parse(fs.readFileSync(options['--change-detection-config-json'], 'utf8'));
     settings.secondsToSleep = options['--seconds-to-sleep'];

     fetchManifestAndAnalyzeData(options['--server-config-json']);
 }

 function fetchManifestAndAnalyzeData(serverConfigJSON)
 {
     loadServerConfig(serverConfigJSON);

     getJSON(settings.perfserver, '/data/manifest.json').then(function (manifest) {
         return mapInOrder(configurationsForTesting(manifest), analyzeConfiguration);
     }).catch(function (reason) {
         console.error('Failed to obtain the manifest file', reason);
     }).then(function () {
         console.log('');
         console.log('Sleeing for', settings.secondsToSleep, 'seconds');
         setTimeout(function () {
             fetchManifestAndAnalyzeData(serverConfigJSON);
         }, settings.secondsToSleep * 1000);
     });
 }

 function loadServerConfig(serverConfigJSON)
 {
     var serverConfig = JSON.parse(fs.readFileSync(serverConfigJSON, 'utf8'));

     var server = serverConfig['server'];
     if ('auth' in server)
         server['auth'] = server['auth']['username'] + ':' + server['auth']['password'];

     settings.perfserver = server;
     settings.slave = serverConfig['slave'];
 }

 function mapInOrder(array, callback, startIndex)
 {
     if (startIndex === undefined)
         startIndex = 0;
     if (startIndex >= array.length)
         return;

     var next = function () { return mapInOrder(array, callback, startIndex + 1); };
     var returnValue = callback(array[startIndex]);
     if (typeof(returnValue) === 'object' && returnValue instanceof Promise)
         return returnValue.then(next).catch(next);
     return next();
 }

 function configurationsForTesting(manifest)
 {
     var configurations = [];
     for (var name in manifest.dashboards) {
         var dashboard = manifest.dashboards[name];
         for (var row of dashboard) {
             for (var cell of row) {
                 if (cell instanceof Array) {
                     var platformId = parseInt(cell[0]);
                     var metricId = parseInt(cell[1]);
                     if (!isNaN(platformId) && !isNaN(metricId))
                         configurations.push({platformId: platformId, metricId: metricId});
                 }
             }
         }
     }

     var platforms = manifest.all;
     for (var config of configurations) {
         var metric = manifest.metrics[config.metricId];

         var testPath = [];
         var id = metric.test;
         while (id) {
             var test = manifest.tests[id];
             testPath.push(test.name);
             id = test.parentId;
         }

         config.unit = RunsData.unitFromMetricName(metric.name);
         config.smallerIsBetter = RunsData.isSmallerBetter(config.unit);
         config.platformName = platforms[config.platformId].name;
         config.testName = testPath.reverse().join(' > ');
         config.fullTestName = config.testName + ':' + metric.name;
         config.repositories = manifest.repositories;
         if (metric.aggregator)
             config.fullTestName += ':' + metric.aggregator;
     }

     return configurations;
 }

 function analyzeConfiguration(config)
 {
     var minTime = Date.now() - settings.maxDays * 24 * 3600 * 1000;

     console.log('');
     console.log('== Analyzing the last', settings.maxDays, 'days:', config.fullTestName, 'on', config.platformName, '==');

     return computeRangesForTesting(settings.perfserver, settings.strategies, config.platformId, config.metricId).then(function (ranges) {
         var filteredRanges = ranges.filter(function (range) { return range.endTime >= minTime && !range.overlappingAnalysisTasks.length; })
             .sort(function (a, b) { return a.endTime - b.endTime });

         var summary;
         var range;
         for (range of filteredRanges) {
             var summary = summarizeRange(config, range);
             console.log('Detected:', summary);
         }

         if (!range) {
             console.log('Nothing to analyze');
             return;
         }

         return createAnalysisTaskAndNotify(config, range, summary);
     });
 }

 function computeRangesForTesting(server, strategies, platformId, metricId)
 {
     // FIXME: Store the segmentation strategy on the server side.
     // FIXME: Configure each strategy.
     var segmentationStrategy = findStrategyByLabel(StatisticsStrategies.MovingAverageStrategies, strategies.segmentation.label);
     if (!segmentationStrategy) {
         console.error('Failed to find the segmentation strategy: ' + strategies.segmentation.label);
         return;
     }

     var testRangeStrategy = findStrategyByLabel(StatisticsStrategies.TestRangeSelectionStrategies, strategies.testRange.label);
     if (!testRangeStrategy) {
         console.error('Failed to find the test range selection strategy: ' + strategies.testRange.label);
         return;
     }

     var currentPromise = getJSON(server, RunsData.pathForFetchingRuns(platformId, metricId)).then(function (response) {
         if (response.status != 'OK')
             throw response;
         return RunsData.createRunsDataInResponse(response).configurations.current;
     }, function (reason) {
         console.error('Failed to fetch the measurements:', reason);
     });

     var analysisTasksPromise = getJSON(server, '/api/analysis-tasks?platform=' + platformId + '&metric=' + metricId).then(function (response) {
         if (response.status != 'OK')
             throw response;
         return response.analysisTasks.filter(function (task) { return task.startRun && task.endRun; });
     }, function (reason) {
         console.error('Failed to fetch the analysis tasks:', reason);
     });

     return Promise.all([currentPromise, analysisTasksPromise]).then(function (results) {
         var currentTimeSeries = results[0].timeSeriesByCommitTime();
         var analysisTasks = results[1];
         var rawValues = currentTimeSeries.rawValues();
         var segmentedValues = StatisticsStrategies.executeStrategy(segmentationStrategy, rawValues);

         var ranges = StatisticsStrategies.executeStrategy(testRangeStrategy, rawValues, [segmentedValues]).map(function (range) {
             var startPoint = currentTimeSeries.findPointByIndex(range[0]);
             var endPoint = currentTimeSeries.findPointByIndex(range[1]);
             return {
                 startIndex: range[0],
                 endIndex: range[1],
                 overlappingAnalysisTasks: [],
                 startTime: startPoint.time,
                 endTime: endPoint.time,
                 relativeChangeInSegmentedValues: (segmentedValues[range[1]] - segmentedValues[range[0]]) / segmentedValues[range[0]],
                 startMeasurement: startPoint.measurement,
                 endMeasurement: endPoint.measurement,
             };
         });

         for (var task of analysisTasks) {
             var taskStartPoint = currentTimeSeries.findPointByMeasurementId(task.startRun);
             var taskEndPoint = currentTimeSeries.findPointByMeasurementId(task.endRun);
             for (var range of ranges) {
                 var disjoint = range.endIndex < taskStartPoint.seriesIndex
                     || taskEndPoint.seriesIndex < range.startIndex;
                 if (!disjoint)
                     range.overlappingAnalysisTasks.push(task);
             }
         }

         return ranges;
     });
 }

 function createAnalysisTaskAndNotify(config, range, summary)
 {
     var segmentationStrategy = settings.strategies.segmentation.label;
     var testRangeStrategy = settings.strategies.testRange.label;

     var analysisTaskData = {
         name: summary,
         startRun: range.startMeasurement.id(),
         endRun: range.endMeasurement.id(),
         segmentationStrategy: segmentationStrategy,
         testRangeStrategy: testRangeStrategy,

         slaveName: settings.slave.name,
         slavePassword: settings.slave.password,
     };

     return postJSON(settings.perfserver, '/privileged-api/create-analysis-task', analysisTaskData).then(function (response) {
         if (response['status'] != 'OK')
             throw response;

         var analysisTaskId = response['taskId'];

         var title = '[' + config.testName + '][' + config.platformName + '] ' + summary;
         var analysisTaskURL = settings.perfserver.scheme + '://' + settings.perfserver.host + '/v2/#/analysis/task/' + analysisTaskId;
         var changeType = changeTypeForRange(config, range);
         // FIXME: Templatize this.
         var message = '<b>' + settings.notification.serviceName + '</b> detected a potential ' + changeType + ':<br><br>'
             + '<table border=1><caption>' + summary + '</caption><tbody>'
             + '<tr><th>Test</th><td>' + config.fullTestName + '</td></tr>'
             + '<tr><th>Platform</th><td>' + config.platformName + '</td></tr>'
             + '<tr><th>Algorithm</th><td>' + segmentationStrategy + '<br>' + testRangeStrategy + '</td></tr>'
             + '</table><br>'
             + '<a href="' + analysisTaskURL + '">Open the analysis task</a>';

         return getJSON(settings.perfserver, '/api/triggerables?task=' + analysisTaskId).then(function (response) {
             var status = response['status'];
             var triggerables = response['triggerables'] || [];
             if (status == 'TriggerableNotFoundForTask' || triggerables.length != 1) {
                 message += ' (A/B testing was not available)';
                 return;
             }
             if (status != 'OK')
                 throw response;

             var triggerable = response['triggerables'][0];
             var commitSets = {};
             for (var repositoryId of triggerable['acceptedRepositories']) {
                 var startRevision = range.startMeasurement.revisionForRepository(repositoryId);
                 var endRevision = range.endMeasurement.revisionForRepository(repositoryId);
                 if (startRevision == null || endRevision == null)
                     continue;
                 commitSets[config.repositories[repositoryId].name] = [startRevision, endRevision];
             }

             var testData = {
                 task: analysisTaskId,
                 name: 'Confirming the ' + changeType,
                 commitSets: commitSets,
                 repetitionCount: Math.max(2, Math.min(8, Math.floor((range.endIndex - range.startIndex) / 4))),

                 slaveName: settings.slave.name,
                 slavePassword: settings.slave.password,
             };

             return postJSON(settings.perfserver, '/privileged-api/create-test-group', testData).then(function (response) {
                 if (response['status'] != 'OK')
                     throw response;
                 message += ' (triggered an A/B testing)';
             });
         }).catch(function (reason) {
             console.error(reason);
             message += ' (failed to create a new A/B testing)';
         }).then(function () {
             return postNotification(settings.notification.server, settings.notification.template, title, message).then(function () {
                 console.log('  Sent a notification');
             }, function (reason) {
                 console.error('  Failed to send a notification', reason);
             });
         });
     }).catch(function (reason) {
         console.error('  Failed to create an analysis task', reason);
     });
 }

 function findStrategyByLabel(list, label)
 {
     for (var strategy of list) {
         if (strategy.label == label)
             return strategy;
     }
     return null;
 }

 function changeTypeForRange(config, range)
 {
     var endValueIsLarger = range.relativeChangeInSegmentedValues > 0;
     return endValueIsLarger == config.smallerIsBetter ? 'regression' : 'progression';
 }

 function summarizeRange(config, range)
 {
     return 'Potential ' + Math.abs(range.relativeChangeInSegmentedValues * 100).toPrecision(2) + '% '
         + changeTypeForRange(config, range) + ' between ' + formatTimeRange(range.startTime, range.endTime);
 }

 function formatTimeRange(start, end)
 {
     var formatter = function (date) { return date.toISOString().replace('T', ' ').replace(/:\d{2}\.\d+Z$/, ''); }
     var formattedStart = formatter(start);
     var formattedEnd = formatter(end);
     if (start.toDateString() == end.toDateString())
         return formattedStart + ' and ' + formattedEnd.substring(formattedEnd.indexOf(' ') + 1);
     if (start.getFullYear() == end.getFullYear())
         return formattedStart + ' and ' + formattedEnd.substring(5);
     return formattedStart + ' and ' + formattedEnd;
 }

 function getJSON(server, path, data)
 {
     return fetchJSON(server.scheme, {
         'hostname': server.host,
         'port': server.port,
         'auth': server.auth,
         'path': path,
         'method': 'GET',
     }, 'application/json');
 }

 function postJSON(server, path, data)
 {
     return fetchJSON(server.scheme, {
         'hostname': server.host,
         'port': server.port,
         'auth': server.auth,
         'path': path,
         'method': 'POST',
     }, 'application/json', JSON.stringify(data));
 }

 function postNotification(server, template, title, message)
 {
     var notification = instantiateNotificationTemplate(template, title, message);
     return fetchJSON(server.scheme, {
         'hostname': server.host,
         'port': server.port,
         'auth': server.auth,
         'path': server.path,
         'method': server.method,
     }, 'application/json', JSON.stringify(notification));
 }

 function instantiateNotificationTemplate(template, title, message)
 {
     var instance = {};
     for (var name in template) {
         var value = template[name];
         if (typeof(value) === 'string')
             instance[name] = value.replace(/\$title/g, title).replace(/\$message/g, message);
         else if (typeof(template[name]) === 'object')
             instance[name] = instantiateNotificationTemplate(value, title, message);
         else
             instance[name] = value;
     }
     return instance;
 }

 function fetchJSON(schemeName, options, contentType, content) {
     var requester = schemeName == 'https' ? https : http;
     return new Promise(function (resolve, reject) {
         var request = requester.request(options, function (response) {
             var responseText = '';
             response.setEncoding('utf8');
             response.on('data', function (chunk) { responseText += chunk; });
             response.on('end', function () {
                 try {
                     var json = JSON.parse(responseText);
                 } catch (error) {
                     reject({error: error, responseText: responseText});
                 }
                 resolve(json);
             });
         });
         request.on('error', function (error) { reject(error); });
         if (contentType)
             request.setHeader('Content-Type', contentType);
         if (content)
             request.write(content);
         request.end();
     });
 }

 main(process.argv);
	#!/usr/local/bin/node

	var fs = require('fs');
	var http = require('http');
	var https = require('https');
	var data = require('../public/v2/data.js');
	var RunsData = data.RunsData;
	var Statistics = require('../public/shared/statistics.js');
	var StatisticsStrategies = require('../public/v2/statistics-strategies.js');
	var parseArguments = require('./js/parse-arguments.js').parseArguments;

	// FIXME: We shouldn't use a global variable like this.
	var settings;
	function main(argv)
	{
	var options = parseArguments(argv, [
	{name: '--server-config-json', required: true},
	{name: '--change-detection-config-json', required: true},
	{name: '--seconds-to-sleep', type: parseFloat, default: 1200},
	]);
	if (!options)
	return;

	settings = JSON.parse(fs.readFileSync(options['--change-detection-config-json'], 'utf8'));
	settings.secondsToSleep = options['--seconds-to-sleep'];

	fetchManifestAndAnalyzeData(options['--server-config-json']);
	}

	function fetchManifestAndAnalyzeData(serverConfigJSON)
	{
	loadServerConfig(serverConfigJSON);

	getJSON(settings.perfserver, '/data/manifest.json').then(function (manifest) {
	return mapInOrder(configurationsForTesting(manifest), analyzeConfiguration);
	}).catch(function (reason) {
	console.error('Failed to obtain the manifest file', reason);
	}).then(function () {
	console.log('');
	console.log('Sleeing for', settings.secondsToSleep, 'seconds');
	setTimeout(function () {
	fetchManifestAndAnalyzeData(serverConfigJSON);
	}, settings.secondsToSleep * 1000);
	});
	}

	function loadServerConfig(serverConfigJSON)
	{
	var serverConfig = JSON.parse(fs.readFileSync(serverConfigJSON, 'utf8'));

	var server = serverConfig['server'];
	if ('auth' in server)
	server['auth'] = server['auth']['username'] + ':' + server['auth']['password'];

	settings.perfserver = server;
	settings.slave = serverConfig['slave'];
	}

	function mapInOrder(array, callback, startIndex)
	{
	if (startIndex === undefined)
	startIndex = 0;
	if (startIndex >= array.length)
	return;

	var next = function () { return mapInOrder(array, callback, startIndex + 1); };
	var returnValue = callback(array[startIndex]);
	if (typeof(returnValue) === 'object' && returnValue instanceof Promise)
	return returnValue.then(next).catch(next);
	return next();
	}

	function configurationsForTesting(manifest)
	{
	var configurations = [];
	for (var name in manifest.dashboards) {
	var dashboard = manifest.dashboards[name];
	for (var row of dashboard) {
	for (var cell of row) {
	if (cell instanceof Array) {
	var platformId = parseInt(cell[0]);
	var metricId = parseInt(cell[1]);
	if (!isNaN(platformId) && !isNaN(metricId))
	configurations.push({platformId: platformId, metricId: metricId});
	}
	}
	}
	}

	var platforms = manifest.all;
	for (var config of configurations) {
	var metric = manifest.metrics[config.metricId];

	var testPath = [];
	var id = metric.test;
	while (id) {
	var test = manifest.tests[id];
	testPath.push(test.name);
	id = test.parentId;
	}

	config.unit = RunsData.unitFromMetricName(metric.name);
	config.smallerIsBetter = RunsData.isSmallerBetter(config.unit);
	config.platformName = platforms[config.platformId].name;
	config.testName = testPath.reverse().join(' > ');
	config.fullTestName = config.testName + ':' + metric.name;
	config.repositories = manifest.repositories;
	if (metric.aggregator)
	config.fullTestName += ':' + metric.aggregator;
	}

	return configurations;
	}

	function analyzeConfiguration(config)
	{
	var minTime = Date.now() - settings.maxDays * 24 * 3600 * 1000;

	console.log('');
	console.log('== Analyzing the last', settings.maxDays, 'days:', config.fullTestName, 'on', config.platformName, '==');

	return computeRangesForTesting(settings.perfserver, settings.strategies, config.platformId, config.metricId).then(function (ranges) {
	var filteredRanges = ranges.filter(function (range) { return range.endTime >= minTime && !range.overlappingAnalysisTasks.length; })
	.sort(function (a, b) { return a.endTime - b.endTime });

	var summary;
	var range;
	for (range of filteredRanges) {
	var summary = summarizeRange(config, range);
	console.log('Detected:', summary);
	}

	if (!range) {
	console.log('Nothing to analyze');
	return;
	}

	return createAnalysisTaskAndNotify(config, range, summary);
	});
	}

	function computeRangesForTesting(server, strategies, platformId, metricId)
	{
	// FIXME: Store the segmentation strategy on the server side.
	// FIXME: Configure each strategy.
	var segmentationStrategy = findStrategyByLabel(StatisticsStrategies.MovingAverageStrategies, strategies.segmentation.label);
	if (!segmentationStrategy) {
	console.error('Failed to find the segmentation strategy: ' + strategies.segmentation.label);
	return;
	}

	var testRangeStrategy = findStrategyByLabel(StatisticsStrategies.TestRangeSelectionStrategies, strategies.testRange.label);
	if (!testRangeStrategy) {
	console.error('Failed to find the test range selection strategy: ' + strategies.testRange.label);
	return;
	}

	var currentPromise = getJSON(server, RunsData.pathForFetchingRuns(platformId, metricId)).then(function (response) {
	if (response.status != 'OK')
	throw response;
	return RunsData.createRunsDataInResponse(response).configurations.current;
	}, function (reason) {
	console.error('Failed to fetch the measurements:', reason);
	});

	var analysisTasksPromise = getJSON(server, '/api/analysis-tasks?platform=' + platformId + '&metric=' + metricId).then(function (response) {
	if (response.status != 'OK')
	throw response;
	return response.analysisTasks.filter(function (task) { return task.startRun && task.endRun; });
	}, function (reason) {
	console.error('Failed to fetch the analysis tasks:', reason);
	});

	return Promise.all([currentPromise, analysisTasksPromise]).then(function (results) {
	var currentTimeSeries = results[0].timeSeriesByCommitTime();
	var analysisTasks = results[1];
	var rawValues = currentTimeSeries.rawValues();
	var segmentedValues = StatisticsStrategies.executeStrategy(segmentationStrategy, rawValues);

	var ranges = StatisticsStrategies.executeStrategy(testRangeStrategy, rawValues, [segmentedValues]).map(function (range) {
	var startPoint = currentTimeSeries.findPointByIndex(range[0]);
	var endPoint = currentTimeSeries.findPointByIndex(range[1]);
	return {
	startIndex: range[0],
	endIndex: range[1],
	overlappingAnalysisTasks: [],
	startTime: startPoint.time,
	endTime: endPoint.time,
	relativeChangeInSegmentedValues: (segmentedValues[range[1]] - segmentedValues[range[0]]) / segmentedValues[range[0]],
	startMeasurement: startPoint.measurement,
	endMeasurement: endPoint.measurement,
	};
	});

	for (var task of analysisTasks) {
	var taskStartPoint = currentTimeSeries.findPointByMeasurementId(task.startRun);
	var taskEndPoint = currentTimeSeries.findPointByMeasurementId(task.endRun);
	for (var range of ranges) {
	var disjoint = range.endIndex < taskStartPoint.seriesIndex
	\|\| taskEndPoint.seriesIndex < range.startIndex;
	if (!disjoint)
	range.overlappingAnalysisTasks.push(task);
	}
	}

	return ranges;
	});
	}

	function createAnalysisTaskAndNotify(config, range, summary)
	{
	var segmentationStrategy = settings.strategies.segmentation.label;
	var testRangeStrategy = settings.strategies.testRange.label;

	var analysisTaskData = {
	name: summary,
	startRun: range.startMeasurement.id(),
	endRun: range.endMeasurement.id(),
	segmentationStrategy: segmentationStrategy,
	testRangeStrategy: testRangeStrategy,

	slaveName: settings.slave.name,
	slavePassword: settings.slave.password,
	};

	return postJSON(settings.perfserver, '/privileged-api/create-analysis-task', analysisTaskData).then(function (response) {
	if (response['status'] != 'OK')
	throw response;

	var analysisTaskId = response['taskId'];

	var title = '[' + config.testName + '][' + config.platformName + '] ' + summary;
	var analysisTaskURL = settings.perfserver.scheme + '://' + settings.perfserver.host + '/v2/#/analysis/task/' + analysisTaskId;
	var changeType = changeTypeForRange(config, range);
	// FIXME: Templatize this.
	var message = '<b>' + settings.notification.serviceName + '</b> detected a potential ' + changeType + ':<br><br>'
	+ '<table border=1><caption>' + summary + '</caption><tbody>'
	+ '<tr><th>Test</th><td>' + config.fullTestName + '</td></tr>'
	+ '<tr><th>Platform</th><td>' + config.platformName + '</td></tr>'
	+ '<tr><th>Algorithm</th><td>' + segmentationStrategy + '<br>' + testRangeStrategy + '</td></tr>'
	+ '</table><br>'
	+ '<a href="' + analysisTaskURL + '">Open the analysis task</a>';

	return getJSON(settings.perfserver, '/api/triggerables?task=' + analysisTaskId).then(function (response) {
	var status = response['status'];
	var triggerables = response['triggerables'] \|\| [];
	if (status == 'TriggerableNotFoundForTask' \|\| triggerables.length != 1) {
	message += ' (A/B testing was not available)';
	return;
	}
	if (status != 'OK')
	throw response;

	var triggerable = response['triggerables'][0];
	var commitSets = {};
	for (var repositoryId of triggerable['acceptedRepositories']) {
	var startRevision = range.startMeasurement.revisionForRepository(repositoryId);
	var endRevision = range.endMeasurement.revisionForRepository(repositoryId);
	if (startRevision == null \|\| endRevision == null)
	continue;
	commitSets[config.repositories[repositoryId].name] = [startRevision, endRevision];
	}

	var testData = {
	task: analysisTaskId,
	name: 'Confirming the ' + changeType,
	commitSets: commitSets,
	repetitionCount: Math.max(2, Math.min(8, Math.floor((range.endIndex - range.startIndex) / 4))),

	slaveName: settings.slave.name,
	slavePassword: settings.slave.password,
	};

	return postJSON(settings.perfserver, '/privileged-api/create-test-group', testData).then(function (response) {
	if (response['status'] != 'OK')
	throw response;
	message += ' (triggered an A/B testing)';
	});
	}).catch(function (reason) {
	console.error(reason);
	message += ' (failed to create a new A/B testing)';
	}).then(function () {
	return postNotification(settings.notification.server, settings.notification.template, title, message).then(function () {
	console.log(' Sent a notification');
	}, function (reason) {
	console.error(' Failed to send a notification', reason);
	});
	});
	}).catch(function (reason) {
	console.error(' Failed to create an analysis task', reason);
	});
	}

	function findStrategyByLabel(list, label)
	{
	for (var strategy of list) {
	if (strategy.label == label)
	return strategy;
	}
	return null;
	}

	function changeTypeForRange(config, range)
	{
	var endValueIsLarger = range.relativeChangeInSegmentedValues > 0;
	return endValueIsLarger == config.smallerIsBetter ? 'regression' : 'progression';
	}

	function summarizeRange(config, range)
	{
	return 'Potential ' + Math.abs(range.relativeChangeInSegmentedValues * 100).toPrecision(2) + '% '
	+ changeTypeForRange(config, range) + ' between ' + formatTimeRange(range.startTime, range.endTime);
	}

	function formatTimeRange(start, end)
	{
	var formatter = function (date) { return date.toISOString().replace('T', ' ').replace(/:\d{2}\.\d+Z$/, ''); }
	var formattedStart = formatter(start);
	var formattedEnd = formatter(end);
	if (start.toDateString() == end.toDateString())
	return formattedStart + ' and ' + formattedEnd.substring(formattedEnd.indexOf(' ') + 1);
	if (start.getFullYear() == end.getFullYear())
	return formattedStart + ' and ' + formattedEnd.substring(5);
	return formattedStart + ' and ' + formattedEnd;
	}

	function getJSON(server, path, data)
	{
	return fetchJSON(server.scheme, {
	'hostname': server.host,
	'port': server.port,
	'auth': server.auth,
	'path': path,
	'method': 'GET',
	}, 'application/json');
	}

	function postJSON(server, path, data)
	{
	return fetchJSON(server.scheme, {
	'hostname': server.host,
	'port': server.port,
	'auth': server.auth,
	'path': path,
	'method': 'POST',
	}, 'application/json', JSON.stringify(data));
	}

	function postNotification(server, template, title, message)
	{
	var notification = instantiateNotificationTemplate(template, title, message);
	return fetchJSON(server.scheme, {
	'hostname': server.host,
	'port': server.port,
	'auth': server.auth,
	'path': server.path,
	'method': server.method,
	}, 'application/json', JSON.stringify(notification));
	}

	function instantiateNotificationTemplate(template, title, message)
	{
	var instance = {};
	for (var name in template) {
	var value = template[name];
	if (typeof(value) === 'string')
	instance[name] = value.replace(/\$title/g, title).replace(/\$message/g, message);
	else if (typeof(template[name]) === 'object')
	instance[name] = instantiateNotificationTemplate(value, title, message);
	else
	instance[name] = value;
	}
	return instance;
	}

	function fetchJSON(schemeName, options, contentType, content) {
	var requester = schemeName == 'https' ? https : http;
	return new Promise(function (resolve, reject) {
	var request = requester.request(options, function (response) {
	var responseText = '';
	response.setEncoding('utf8');
	response.on('data', function (chunk) { responseText += chunk; });
	response.on('end', function () {
	try {
	var json = JSON.parse(responseText);
	} catch (error) {
	reject({error: error, responseText: responseText});
	}
	resolve(json);
	});
	});
	request.on('error', function (error) { reject(error); });
	if (contentType)
	request.setHeader('Content-Type', contentType);
	if (content)
	request.write(content);
	request.end();
	});
	}

	main(process.argv);