sl-cia/lib/instrumentation/browser-instrumenter.js

var path = require('path');
var mkdirp = require('mkdirp');
var async = require('async');
var fs = require('fs');
var libInstrument = require('istanbul-lib-instrument');
var SlJsInfra = require('sl-js-infra').SlJsInfra;
var fileAndFolderUtils = require('../file-and-folder-utils');
var utils = require('../utils');
var ValidationUtils = SlJsInfra.Utils.ValidationUtils;
var FileInstrumenter  = require("./file-instrumenter");
var MarkupFileInstrumenter  = require("./markup-file-instrumenter");
var IgnoredFilesHandler = SlJsInfra.IgnoredFilesHandler;
var CiaEnvVars = SlJsInfra.SlEnvVars.CIA;
/**
 * * This class responsible to instrument a set of files with Sealights information.
 * @param {* Instrumentation options} opts
 * @param {* A logger} logger
 */
function BrowserInstrumenter(opts, logger, slMapper) {
    ValidationUtils.verifyNotNullOrEmpty(opts, "opts");
    ValidationUtils.verifyNotNullOrEmpty(logger, "logger");
    ValidationUtils.verifyNotNullOrEmpty(slMapper, "slMapper");

    this.opts = opts;
    this.logger = logger;
    this.slMapper = slMapper;
    this.files = {
        instrumented: [],
        notInstrumented: [],
        withInstrumentationErrors: [],
        withCopyErrors: []
    }
}


BrowserInstrumenter.prototype.instrument = function (callback) {
	ValidationUtils.verifyNotNullOrEmpty(callback, "callback");

    try {
        var err = this._validate(callback);
        if (err) {
            this.logger.error("Instrumentation failed due to invalid input. Error: ", err);
            return callback(err);
        }

        var hasPhysicalFiles = this.opts.files && this.opts.files.length > 0;
        if (!hasPhysicalFiles) {
            this.logger.warn("Didn't find any files which require instrumentation. Skipping browser instrumentation.")
            return callback();
        }

        this.logger.info("Starting instrumentation process.");
        var _this = this;
        this._processFiles(function () {
            _this._onComplete(callback);
        });
    } catch (e) {
        this.logger.error("Failed during instrumentation. Error: ", e);
        return callback(e);
    }

}

BrowserInstrumenter.prototype._printSummaries = function () {
    var summary = "Instrumentation summary:" +
        "\n\tInstrumented files: " + this.files.instrumented.length +
        "\n\tFiles copied as is (not instrumented): " + this.files.notInstrumented.length +
        "\n\tFiles with instrumentation errors: " + this.files.withInstrumentationErrors.length +
        "\n\tFiles with copy errors: " + this.files.withCopyErrors.length;

    this.logger.info(summary);
}


BrowserInstrumenter.prototype._onComplete = function (callback) {
    var _this = this;
    if (this.opts.copyAllFilesToOutput) {
        fileAndFolderUtils.copyDir(this.opts.sourceRoot, this.opts.outputPath, this.opts.files, function (err) {
            _this.logger.info("Finished copying all files to output. Error: ", err);
            _this._printSummaries();
            return callback(err);
        });
    } else {
        _this._printSummaries();
        return callback(null);
    }
}

BrowserInstrumenter.prototype._onFileCopied = function (inputFile) {
    this.files.notInstrumented.push(inputFile);
}


BrowserInstrumenter.prototype._onFileCopyError = function (inputFile, errorMsg) {
    this.files.withCopyErrors.push({
        file: inputFile,
        error: errorMsg
    })
}

BrowserInstrumenter.prototype._onFileWithInstrumentationError = function (inputFile, errorMsg) {
    this.files.withInstrumentationErrors.push({
        file: inputFile,
        error: errorMsg
    })
}

BrowserInstrumenter.prototype._onFileInstrumented = function (inputFile) {
    this.files.instrumented.push(inputFile)
}

BrowserInstrumenter.prototype._validate = function (callback) {
    var opts = this.opts;

    if (opts.instrumentationType != "browser") {
        return new Error("instrumentationType must be 'browser'");
    }

    if (!opts.extensionsToInstrument || opts.extensionsToInstrument.length === 0) {
        return new Error("'extensionsToInstrument' must specified");
    }

    var hasPhysicalFiles = opts.files && opts.files.length > 0;

    if (hasPhysicalFiles) {
        if (!opts.outputPath) {
            return new Error("outputPath was not specified");
        }

        if (!opts.sourceRoot) {
            return new Error("sourceRoot was not specified");
        }
    }

    if (!opts.server) {
        return new Error("server was not specified");
    }

    if (!opts.token) {
        return new Error("token was not specified");
    }

    if (!opts.customerId) {
        return new Error("customerId was not specified");
    }

    if (!opts.workspacepath) {
        return new Error("workspacepath was not specified");
    }


    //All good.
    return null;
}

function addHtmlTag(preambleHeader, sourceUrl, loadedFlag) {
    preambleHeader.push("if(!window.$Sealights." + loadedFlag + ") {",
        "   var script   = document.createElement(\"script\");",
        "   script.type  = \"text/javascript\";",
        "   script.src   = \"" + sourceUrl + "\";",
        "   var head     = document.head || document.getElementsByTagName && document.getElementsByTagName('head')[0]",
        "   if (head) { head.appendChild(script); window.$Sealights." + loadedFlag + " = true; } else { /* Unsupported/restricted browser */ }",
        "}");
}

BrowserInstrumenter.prototype._createPreamble = function () {
    var opts = this.opts;
    var agentUrl = opts.server;
    if (agentUrl[agentUrl.length] != '/')
        agentUrl += '/';
    agentUrl += 'v1/agents/browser/recommended?redirect=1&customerId=' + encodeURIComponent(opts.customerId);
    var workspacePath = opts.workspacepath;
    if (CiaEnvVars.getSourceRoot() != null){
        workspacePath = CiaEnvVars.getSourceRoot()
        this.logger.info("Overriding 'workspacepath' with 'Source Root'. Old: '" + opts.workspacepath + "', New: '" + workspacePath + "'.");
    }
    var lastChar = workspacePath[workspacePath.length - 1];
    if (lastChar != "\\" && lastChar != "/") {
        workspacePath = workspacePath + "/";
    }
    var preambleHeader = [
        "if (!window.$Sealights) window.$Sealights = " + JSON.stringify({
            customerId: opts.customerId,
            appName: opts.appName,
            buildName: opts.build,
            branchName: opts.branch,
            server: opts.server,
            token: opts.token,
            buildSessionId: opts.buildsessionid,
            labId: opts.labId,
            enabled: true,
            workspacepath: workspacePath,
            maxItemsInQueue: 500,
            registerShutdownHook: true,
            interval: 10, //in seconds
            resolveWithoutHash: opts.resolveWithoutHash,
            delayShutdownInSeconds: opts.delayShutdownInSeconds,
            isUseNewUniqueId: SlJsInfra.SlEnvVars.isUseNewUniqueId()
        }, null, '  ') + ";"];
    if(this.slMapper && opts.slMappingUrl){
        this.slMapper.writeToFile();
        addHtmlTag(preambleHeader, opts.slMappingUrl, "slMappingAdded");
    }

    if (opts.downloadAgent == true) {
        addHtmlTag(preambleHeader, agentUrl, "scriptAdded");
    }


    return preambleHeader;
}

BrowserInstrumenter.prototype._createInstrumenter = function () {
    var config = {
        coverageVariable: "$SealightsCoverage",
        embedSource: false,
        compact: true,
        preserveComments: true,
        esModules: !!this.opts.esModules
    }
    var instrumenter = libInstrument.createInstrumenter(config);

    return instrumenter;
}

BrowserInstrumenter.prototype._createFileInstrumentor = function( preambleHeader, name, slIgnoreWrapper) {
    var extension = path.extname(name);
    if(utils.isMarkupFile(extension)){
        this.logger.debug("'MarkupFileInstrumenter' is active");
        return new MarkupFileInstrumenter(this.opts, preambleHeader, this.instrumenter, name, slIgnoreWrapper, this.logger)
    }
    this.logger.debug("'FileInstrumenter' is active");
    return new FileInstrumenter(this.opts, preambleHeader, this.instrumenter, name, slIgnoreWrapper, this.logger);
}

BrowserInstrumenter.prototype._processFiles = function (callback) {
    var inputDir = this.opts.sourceRoot;
    var outputDir = this.opts.outputPath;
    var relativeNames = this.opts.files;
    var preambleHeader = this._createPreamble()
    this.instrumenter = this._createInstrumenter();
    this.logger.info("Starting to process files. Number of files to process: " + relativeNames.length);
    var IgnoredFilesHandler = this._createIgnoreHandler(SlJsInfra.IgnoredFilesHandler.SCAN_IGNORE_FILE_NAME);

    var extensions = {};
    this.opts.extensionsToInstrument.map(function(ext){
        extensions[ext] = true;
    });


    this.opts.extensionsToInstrument = extensions;
    this.opts.onFileWithInstrumentationError = this._onFileWithInstrumentationError.bind(this);
    this.opts.onFileCopied = this._onFileCopied.bind(this);
    this.opts.onFileInstrumented = this._onFileInstrumented.bind(this);
    this.opts.onFileCopyError = this._onFileCopyError.bind(this);
    var _this = this;

    //Verify the output folder exists
    if(this.opts.outputPath) {
        mkdirp.sync(this.opts.outputPath);
    }
    var processor = function (name, callback) {
        var fi = _this._createFileInstrumentor(preambleHeader, name, IgnoredFilesHandler);
        fi.processSingleFile(callback);
    },

        q = async.queue(processor, 10),
        errors = [],
        count = 0,
        startTime = new Date().getTime();

    q.push(relativeNames, function (err, name) {
        var inputFile, outputFile;
        inputFile = path.resolve(inputDir, name);
        outputFile = path.resolve(outputDir, name);
        if (err) {
            errors.push({
                file: name,
                error: err.message || err.toString()
            });
            fs.writeFileSync(outputFile, fs.readFileSync(inputFile));
            _this.logger.warn("Had error while processing '" + inputFile + "'. File is copied as is. ");
        } else {
            _this.logger.debug("Processed '" + inputFile + "'.")
        }
        // WTF??
        var verbose = false;
        if (verbose) {
            console.log('Processed: ' + name);
        } else {
            if (count % 100 === 0) {
                process.stdout.write('.');
            }
        }
        count += 1;
    });

    q.drain = function () {
        _this.logger.info("Draining the Q.");
        var endTime = new Date().getTime();
        _this.logger.info('\nProcessed [' + count + '] files in ' + Math.floor((endTime - startTime) / 1000) + ' secs');
        if (errors.length > 0) {
            _this.logger.warn('The following ' + errors.length + ' file(s) had errors and were copied as-is:\n' + _this._formatErrorMessage(errors));
        }
        if (callback) {
            callback();
        }
    };
}

BrowserInstrumenter.prototype._createIgnoreHandler = function (filename) {
    var workspacePath = this.opts.workspacepath;
    var slIgnoreScanFilePath = fileAndFolderUtils.findFileRecursively(filename, workspacePath, true, this.logger);
    var slIgnore = new IgnoredFilesHandler(slIgnoreScanFilePath, this.opts.outputpath, filename, this.logger);
    return slIgnore;
}

BrowserInstrumenter.prototype._formatErrorMessage = function (fileWithErrors) {
    var messageFormatter = new SlJsInfra.MessageFormatter();
    var counter = 1;
    fileWithErrors.forEach(function (f) {
        var msg = "[" + counter++ + "] '" + f.file + "'. Error: '" + f.error;
        messageFormatter.addContent(msg);
    })

    return messageFormatter.content;
}

module.exports = BrowserInstrumenter;