@dynatrace/react-native-plugin 2.225.0 → 2.231.0

package/scripts/core/CustomArgumentsImpl.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomArgumentsImpl = void 0;
+class CustomArgumentsImpl {
+    constructor(configurationPath, gradlePath, plistPath) {
+        this.configurationPath = configurationPath;
+        this.gradlePath = gradlePath;
+        this.plistPath = plistPath;
+    }
+    getCustomGradlePath() {
+        return this.gradlePath;
+    }
+    isCustomGradlePathSet() {
+        return this.gradlePath !== undefined;
+    }
+    getCustomPlistPath() {
+        return this.plistPath;
+    }
+    isCustomPlistPathSet() {
+        return this.plistPath !== undefined;
+    }
+    getCustomConfigurationPath() {
+        return this.configurationPath;
+    }
+    isCustomConfigurationPathSet() {
+        return this.configurationPath !== undefined;
+    }
+    isEmpty() {
+        return !(this.isCustomConfigurationPathSet() || this.isCustomGradlePathSet()
+            || this.isCustomPlistPathSet());
+    }
+}
+exports.CustomArgumentsImpl = CustomArgumentsImpl;

package/scripts/core/InstrumentCall.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instrumentCommand = void 0;
+const logger_1 = require("../logger");
+const config_1 = require("../config");
+const android = require("../android");
+const pathsConstants_1 = require("../pathsConstants");
+const ios_1 = require("../ios");
+const instrumentUtil_1 = require("../util/instrumentUtil");
+const path_1 = require("path");
+const CustomArgumentUtil_1 = require("../util/CustomArgumentUtil");
+const Platform_1 = require("../api/model/Platform");
+const SourceMapUtil_1 = require("../util/SourceMapUtil");
+function instrumentCommand() {
+    logger_1.default.logMessageSync("Starting instrumentation of React Native application ..", logger_1.default.INFO);
+    instrumentUtil_1.showVersionOfPlugin();
+    let pathToConfig = pathsConstants_1.default.getConfigFilePath();
+    let pathToGradle = pathsConstants_1.default.getAndroidGradleFile(pathsConstants_1.default.getAndroidFolder());
+    let androidAvailable = true;
+    let pathToPList = undefined;
+    let iosAvailable = true;
+    var argv = CustomArgumentUtil_1.parseCommandLine(process.argv.slice(2));
+    if (argv.isEmpty()) {
+        CustomArgumentUtil_1.clearCustomArguments();
+    }
+    else {
+        CustomArgumentUtil_1.writeCustomArguments(argv);
+    }
+    if (argv.isCustomConfigurationPathSet()) {
+        pathToConfig = argv.getCustomConfigurationPath();
+    }
+    if (argv.isCustomGradlePathSet()) {
+        pathToGradle = argv.getCustomGradlePath();
+        androidAvailable = instrumentUtil_1.isPlatformAvailable(pathToGradle, Platform_1.Platform.Android);
+    }
+    else {
+        androidAvailable = instrumentUtil_1.isPlatformAvailable(pathsConstants_1.default.getAndroidFolder(), Platform_1.Platform.Android);
+    }
+    if (argv.isCustomPlistPathSet()) {
+        pathToPList = path_1.resolve(argv.getCustomPlistPath());
+        iosAvailable = instrumentUtil_1.isPlatformAvailable(pathToPList, Platform_1.Platform.iOS);
+    }
+    else {
+        iosAvailable = instrumentUtil_1.isPlatformAvailable(pathsConstants_1.default.getIOSFolder(), Platform_1.Platform.iOS);
+    }
+    pathToConfig = path_1.resolve(pathToConfig);
+    pathToGradle = path_1.resolve(pathToGradle);
+    if (iosAvailable || androidAvailable) {
+        try {
+            logger_1.default.logMessageSync("Trying to read configuration file: " + pathToConfig, logger_1.default.INFO);
+            let configAgent = config_1.readConfig(pathToConfig);
+            if (androidAvailable) {
+                try {
+                    logger_1.default.logMessageSync("Starting Android Instrumentation with Dynatrace!", logger_1.default.INFO);
+                    android.instrumentAndroidPlatform(pathToGradle, false);
+                    android.writeGradleConfig(configAgent.android);
+                }
+                catch (e) {
+                    logger_1.default.logMessageSync(e.message, logger_1.default.ERROR);
+                }
+                finally {
+                    logger_1.default.logMessageSync("Finished Android Instrumentation with Dynatrace!", logger_1.default.INFO);
+                }
+            }
+            if (iosAvailable) {
+                try {
+                    logger_1.default.logMessageSync("Starting iOS Instrumentation with Dynatrace!", logger_1.default.INFO);
+                    ios_1.default.modifyPListFile(pathToPList, configAgent.ios, false);
+                }
+                catch (e) {
+                    logger_1.default.logMessageSync(e.message, logger_1.default.ERROR);
+                }
+                finally {
+                    logger_1.default.logMessageSync("Finished iOS Instrumentation with Dynatrace!", logger_1.default.INFO);
+                }
+            }
+            SourceMapUtil_1.patchMetroSourceMap();
+        }
+        catch (e) {
+            logger_1.default.logMessageSync(e, logger_1.default.ERROR);
+        }
+    }
+    else {
+        logger_1.default.logMessageSync("Both Android and iOS Folder are not available - Skip instrumentation.", logger_1.default.WARNING);
+    }
+    logger_1.default.logMessageSync("Finished instrumentation of React Native application ..", logger_1.default.INFO);
+    logger_1.default.closeLogFile();
+}
+exports.instrumentCommand = instrumentCommand;

package/scripts/fileOperationHelper.js

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+const path = require("path");
+exports.default = {
+    checkIfFileExists,
+    checkIfFileExistsSync,
+    readTextFromFile,
+    readTextFromFileSync,
+    writeTextToFile,
+    writeTextToFileSync,
+    deleteDirectory,
+    deleteFile,
+    deleteFileSync,
+    createDirectorySync,
+    renameFile,
+    renameFileSync,
+    copyFile,
+    copyFileSync,
+    copyDirectory
+};
+function checkIfFileExists(_file) {
+    return new Promise(function (resolve, reject) {
+        fs.stat(_file, function (err) {
+            if (err) {
+                reject(`${err} - File doesn't exist: ${path.resolve(_file)}`);
+            }
+            resolve(_file);
+        });
+    });
+}
+function checkIfFileExistsSync(_file) {
+    fs.statSync(_file);
+    return _file;
+}
+function readTextFromFileSync(_file) {
+    return fs.readFileSync(_file, "utf8");
+}
+function readTextFromFile(_file) {
+    return new Promise(function (resolve, reject) {
+        fs.readFile(_file, "utf8", (err, data) => {
+            if (err) {
+                reject(err + "Could not read the file: " + path.resolve(_file));
+            }
+            resolve(data);
+        });
+    });
+}
+function writeTextToFile(_file, _text) {
+    return new Promise(function (resolve, reject) {
+        fs.writeFile(_file, _text, (err) => {
+            if (err) {
+                reject(err + " Could not write to file: " + path.resolve(_file));
+            }
+            resolve(_file);
+        });
+    });
+}
+function writeTextToFileSync(_file, _text) {
+    try {
+        fs.writeFileSync(_file, _text);
+        return _file;
+    }
+    catch (err) {
+        throw new Error(err + " Could not write to file: " + path.resolve(_file));
+    }
+}
+function createDirectorySync(directory) {
+    try {
+        mkdirSyncRecursive(directory);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+function mkdirSyncRecursive(directory) {
+    let pathParts = directory.split(path.sep);
+    for (var i = 1; i <= pathParts.length; i++) {
+        var segment = pathParts.slice(0, i).join(path.sep);
+        if (segment.length > 0) {
+            !fs.existsSync(segment) ? fs.mkdirSync(segment) : null;
+        }
+    }
+}
+function deleteDirectory(dir) {
+    return new Promise(function (resolve, reject) {
+        fs.access(dir, function (err) {
+            if (err) {
+                return reject(err);
+            }
+            fs.readdir(dir, function (err, files) {
+                if (err) {
+                    return reject(err);
+                }
+                Promise.all(files.map(function (file) {
+                    return deleteFile(path.join(dir, file));
+                })).then(function () {
+                    fs.rmdir(dir, function (err) {
+                        if (err) {
+                            return reject(err);
+                        }
+                        resolve();
+                    });
+                }).catch(reject);
+            });
+        });
+    });
+}
+function deleteDirectorySync(dir) {
+    fs.accessSync(dir);
+    let files = fs.readdirSync(dir);
+    files.map(function (file) {
+        return deleteFileSync(path.join(dir, file));
+    });
+    fs.rmdirSync(dir);
+}
+function deleteFile(filePath) {
+    return new Promise(function (resolve, reject) {
+        fs.lstat(filePath, function (err, stats) {
+            if (err) {
+                return reject(err);
+            }
+            if (stats.isDirectory()) {
+                resolve(deleteDirectory(filePath));
+            }
+            else {
+                fs.unlink(filePath, function (err) {
+                    if (err) {
+                        return reject(err);
+                    }
+                    resolve();
+                });
+            }
+        });
+    });
+}
+function deleteFileSync(filePath) {
+    let stats = fs.lstatSync(filePath);
+    if (stats.isDirectory()) {
+        deleteDirectorySync(filePath);
+    }
+    else {
+        fs.unlinkSync(filePath);
+    }
+}
+function renameFile(fileOld, fileNew) {
+    return new Promise(function (resolve, reject) {
+        fs.rename(fileOld, fileNew, (err) => {
+            if (err) {
+                reject(err);
+            }
+            resolve();
+        });
+    });
+}
+function renameFileSync(fileOld, fileNew) {
+    fs.renameSync(fileOld, fileNew);
+}
+function copyFile(filePath, destPath) {
+    return new Promise(function (resolve, reject) {
+        fs.copyFile(filePath, destPath, (err) => {
+            if (err) {
+                reject(err);
+            }
+            resolve();
+        });
+    });
+}
+function copyFileSync(filePath, destPath) {
+    fs.copyFileSync(filePath, destPath);
+}
+function copyDirectory(from, to) {
+    fs.mkdirSync(to);
+    fs.readdirSync(from).forEach(element => {
+        if (fs.lstatSync(path.join(from, element)).isFile()) {
+            fs.copyFileSync(path.join(from, element), path.join(to, element));
+        }
+        else {
+            copyDirectory(path.join(from, element), path.join(to, element));
+        }
+    });
+}

package/scripts/install.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("./logger");
+const fileOperationHelper_1 = require("./fileOperationHelper");
+const pathsConstants_1 = require("./pathsConstants");
+const config = require("./config");
+const nodePath = require("path");
+module.exports = (function () {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield modifyPackageJson();
+        yield config.checkConfiguration();
+    });
+}());
+function modifyPackageJson() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            let pathToPackageJson = pathsConstants_1.default.getPackageJsonFile();
+            let packageJson = yield fileOperationHelper_1.default.readTextFromFile(pathToPackageJson);
+            let packageJsonParsed = JSON.parse(packageJson);
+            let instrumentDynatraceValue = "node " + nodePath.relative(pathsConstants_1.default.getApplicationPath(), nodePath.join(__dirname, "instrument.js"));
+            if (packageJsonParsed.scripts == undefined) {
+                packageJsonParsed.scripts = {};
+            }
+            if (packageJsonParsed.scripts.instrumentDynatrace === instrumentDynatraceValue) {
+                logger_1.default.logMessageSync("No need to modify the package.json as it already includes the instrumentDynatrace script!", logger_1.default.INFO);
+            }
+            else {
+                packageJsonParsed.scripts.instrumentDynatrace = instrumentDynatraceValue;
+                yield fileOperationHelper_1.default.writeTextToFile(pathToPackageJson, JSON.stringify(packageJsonParsed, null, "\t"));
+                logger_1.default.logMessageSync("Modified package.json - You are now able to call npm run instrumentDynatrace!", logger_1.default.INFO);
+            }
+        }
+        catch (e) {
+            logger_1.default.logMessageSync("Could not find package.json - please add instrumentDynatrace script manually!", logger_1.default.WARNING);
+        }
+    });
+}

package/scripts/instrument.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const InstrumentCall_1 = require("./core/InstrumentCall");
+module.exports = (function () {
+    InstrumentCall_1.instrumentCommand();
+}());

package/scripts/ios.js

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("./logger");
+const fileOperationHelper_1 = require("./fileOperationHelper");
+const pathsConstants_1 = require("./pathsConstants");
+const plist = require("plist");
+const nodePath = require("path");
+exports.default = {
+    modifyPListFile: modifyPListFile,
+    findPListFile: findPListFile
+};
+function modifyPListFile(pathToPList, iosConfig, removeOnly) {
+    if (pathToPList === undefined) {
+        pathToPList = findPListFile();
+    }
+    else {
+        if (!pathToPList.endsWith(".plist")) {
+            throw new Error("Can't find .plist file. plist path must also include the plist file!");
+        }
+        try {
+            fileOperationHelper_1.default.checkIfFileExistsSync(pathToPList);
+        }
+        catch (e) {
+            throw new Error("Could not read plist file: " + pathToPList);
+        }
+    }
+    let parsedPList = parsePList(pathToPList);
+    let configProps = iosConfig === null || iosConfig === void 0 ? void 0 : iosConfig.config;
+    if (removeOnly) {
+        removePListConfig(pathToPList);
+    }
+    else {
+        if (iosConfig && configProps) {
+            if (hasDuplicateProperties(configProps)) {
+                throw new Error("Duplicate properties found! Please remove duplicates and try again.");
+            }
+            if (isAutoStartEnabled(configProps)) {
+                if (checkForBeaconUrlAndAppId(configProps)) {
+                    createNewPListIfRequired(parsedPList, configProps, pathToPList);
+                }
+                else {
+                    throw new Error("The dynatrace.config.js file does not contain DTXBeaconURL or DTXApplicationID properties. If you want to auto-start the iOS agent, please add these two properties at minimum as they are required. If you are using a manual startup of the iOS agent, please add just the DTXAutoStart property (no other properties are needed and none will be considered) with the value set to false.");
+                }
+            }
+            else {
+                if (checkForBeaconUrlAndAppId(configProps)) {
+                    throw new Error("The dynatrace.config.js file contains DTXBeaconURL and or DTXApplicationID properties while DTXAutoStart is set to false. Any properties that you add to the dynatrace.config.js file will not be used if DTXAutoStart is set to false. If you want to manually start the iOS agent, please only add the DTXAutoStart property and set the value to false.");
+                }
+                else {
+                    createNewPListIfRequired(parsedPList, configProps, pathToPList);
+                }
+            }
+        }
+        else {
+            throw new Error("Can't write configuration of iOS agent because it is missing!");
+        }
+    }
+}
+function removePListConfig(file) {
+    let pListContent = fileOperationHelper_1.default.readTextFromFileSync(file);
+    let pListObj = plist.parse(pListContent);
+    let pListObjCopy = Object.assign({}, pListObj);
+    for (let property in pListObj) {
+        if (property.startsWith("DTX")) {
+            delete pListObjCopy[property];
+        }
+    }
+    fileOperationHelper_1.default.writeTextToFileSync(file, plist.build(pListObjCopy));
+    logger_1.default.logMessageSync("Removed old configuration in plist file: " + file, logger_1.default.INFO);
+}
+function addAgentConfigToPListFile(file, config) {
+    let pListContent = fileOperationHelper_1.default.readTextFromFileSync(file);
+    let newPListContent = `<plist><dict>${config}</dict></plist>`;
+    fileOperationHelper_1.default.writeTextToFileSync(file, plist.build(Object.assign(Object.assign({}, plist.parse(pListContent)), plist.parse(newPListContent))));
+    logger_1.default.logMessageSync("Updated configuration in plist file: " + file, logger_1.default.INFO);
+}
+function findPListFile() {
+    let appJson = fileOperationHelper_1.default.readTextFromFileSync(pathsConstants_1.default.getAppJsonFile());
+    let appJsonObj = JSON.parse(appJson);
+    let appName;
+    if (appJsonObj.expo !== undefined) {
+        appName = appJsonObj.expo.name;
+    }
+    else if (appJsonObj.name !== undefined) {
+        appName = appJsonObj.name;
+    }
+    else {
+        throw new Error("Name of the application is unknown. Check your app.json file!");
+    }
+    let pListPaths = [];
+    pListPaths.push(nodePath.join(pathsConstants_1.default.getIOSFolder(), appName, "Info.plist"));
+    pListPaths.push(nodePath.join(pathsConstants_1.default.getIOSFolder(), appName, "Supporting", "Info.plist"));
+    for (let i = 0; i < pListPaths.length; i++) {
+        try {
+            fileOperationHelper_1.default.checkIfFileExistsSync(pListPaths[i]);
+            return pListPaths[i];
+        }
+        catch (e) {
+        }
+    }
+    throw new Error("Can't find .plist file in iOS Folder! Try to use plist= custom argument. See documentation for help!");
+}
+function parsePList(file) {
+    let pListContent = fileOperationHelper_1.default.readTextFromFileSync(file);
+    let pListObj = plist.parse(pListContent);
+    return pListObj = Object.assign({}, pListObj);
+}
+function isAutoStartEnabled(config) {
+    if (config && config.indexOf("<key>DTXAutoStart</key>") === -1) {
+        return true;
+    }
+    let configObj = "<plist><dict>" + config + "</dict></plist>";
+    let configObjCopy = plist.parse(configObj);
+    let configKeys = Object.keys(configObjCopy);
+    let configValues = Object.values(configObjCopy);
+    for (let key in configKeys) {
+        if (configKeys[key] === "DTXAutoStart" && configValues[key]) {
+            return true;
+        }
+    }
+    return false;
+}
+function checkForBeaconUrlAndAppId(config) {
+    return config != null && config.indexOf("DTXApplicationID") >= 0 && config.indexOf("DTXBeaconURL") >= 0;
+}
+function isPropertyCountEqual(parsedPList, config) {
+    let configObj = "<plist><dict>" + config + "</dict></plist>";
+    let configObjCopy = plist.parse(configObj);
+    return Object.keys(parsedPList).filter(pListDtxKeys => pListDtxKeys.startsWith("DTX")).length === Object.keys(configObjCopy).filter(configDtxKeys => configDtxKeys.startsWith("DTX")).length;
+}
+function areConfigsEqual(parsedPList, configObj) {
+    let pListKeys = Object.keys(parsedPList);
+    for (let property of pListKeys) {
+        let plistProperty = parsedPList[property];
+        let configProperty = configObj[property];
+        let objectProperties = isPropertyAnObject(plistProperty) && isPropertyAnObject(configProperty);
+        if (objectProperties && !areConfigsEqual(plistProperty, configProperty) ||
+            !objectProperties && plistProperty !== configProperty) {
+            return false;
+        }
+    }
+    return true;
+}
+function comparePListAndConfig(pListObj, config) {
+    let configObj = "<plist><dict>" + config + "</dict></plist>";
+    let configObjCopy = plist.parse(configObj);
+    removeNonDTXProperties(pListObj);
+    removeNonDTXProperties(configObjCopy);
+    return areConfigsEqual(pListObj, configObjCopy);
+}
+function isPropertyAnObject(propertyObject) {
+    return propertyObject != null && typeof propertyObject === 'object';
+}
+function removeNonDTXProperties(propertiesObject) {
+    let updatedObject = propertiesObject;
+    for (let property in propertiesObject) {
+        if (!property.startsWith("DTX")) {
+            delete updatedObject[property];
+        }
+    }
+    return updatedObject;
+}
+function hasDuplicateProperties(config) {
+    let configArr = config.split("\n");
+    let newConfigArr = configArr.filter(configDtxKeys => configDtxKeys.startsWith("<key>DTX"));
+    return !newConfigArr.every(property => newConfigArr.indexOf(property) === newConfigArr.lastIndexOf(property));
+}
+function createNewPListIfRequired(parsedPList, configProps, pathToPList) {
+    let configIncludingFlavor = configProps + "<key>DTXFlavor</key>\n<string>react_native</string>";
+    if (isPropertyCountEqual(parsedPList, configIncludingFlavor) && comparePListAndConfig(parsedPList, configIncludingFlavor)) {
+        logger_1.default.logMessageSync("Not generating a new plist as the current plist and dynatrace.config.js iOS properties are identical!", logger_1.default.INFO);
+    }
+    else {
+        logger_1.default.logMessageSync("Generating a new plist as the current plist and dynatrace.config.js iOS properties do not match!", logger_1.default.INFO);
+        removePListConfig(pathToPList);
+        addAgentConfigToPListFile(pathToPList, configIncludingFlavor);
+    }
+}

package/scripts/logger.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fileOperationHelper_1 = require("./fileOperationHelper");
+const pathsConstants_1 = require("./pathsConstants");
+const config_1 = require("./config");
+const fs = require("fs");
+const nodePath = require("path");
+const ERROR = 0;
+const INFO = 1;
+const WARNING = 2;
+exports.default = {
+    ERROR: ERROR,
+    INFO: INFO,
+    WARNING: WARNING,
+    closeLogFile: closeLogFile,
+    logMessageSync: logMessageSync,
+    logErrorSync: logErrorSync
+};
+function closeLogFile() {
+    if (process.env.SILENT == "true") {
+        return;
+    }
+    return fileOperationHelper_1.default.checkIfFileExists(pathsConstants_1.default.getCurrentLogPath())
+        .then((_file) => {
+        return new Promise(function (resolve, reject) {
+            let logFileName = currentDate().split(":").join("-") + ".txt";
+            fs.rename(_file, nodePath.join(pathsConstants_1.default.getLogPath(), logFileName), (err) => {
+                if (err) {
+                    reject("Renaming of the log file failed!");
+                }
+                resolve(nodePath.join(pathsConstants_1.default.getLogPath(), logFileName));
+            });
+        });
+    })
+        .catch(errorHandling);
+}
+function logErrorSync(_message) {
+    let config = config_1.readConfig(pathsConstants_1.default.getConfigFilePath());
+    if (config.react !== undefined && config.react.debug) {
+        logMessageSync(_message, ERROR, true);
+    }
+}
+function logMessageSync(_message, _logLevel, _onlyConsole = false) {
+    if (process.env.SILENT == "true") {
+        return;
+    }
+    try {
+        fs.mkdirSync(pathsConstants_1.default.getLogPath());
+    }
+    catch (e) {
+    }
+    let logString;
+    if (_logLevel == INFO) {
+        logString = "#INFO  ";
+    }
+    else if (_logLevel == WARNING) {
+        logString = "#WARN  ";
+    }
+    else if (_logLevel == ERROR) {
+        logString = "#ERROR ";
+    }
+    else {
+        logString = "#NONE  ";
+    }
+    let outputString = logString + "[" + currentDate() + "]: " + _message;
+    console.log(outputString);
+    if (!_onlyConsole) {
+        fs.appendFileSync(pathsConstants_1.default.getCurrentLogPath(), outputString + "\r\n");
+    }
+}
+function errorHandling(_message) {
+    console.log(_message);
+}
+function currentDate() {
+    let tzoffset = (new Date()).getTimezoneOffset() * 60000;
+    let localISOTime = (new Date(Date.now() - tzoffset)).toISOString().slice(0, -5);
+    return localISOTime.replace("T", " ");
+}

package/scripts/pathsConstants.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const nodePath = require("path");
+const PATH_FILES = "files";
+const PATH_LOGS = "logs";
+var rootPath = __dirname;
+exports.default = {
+    setRoot: function (newRoot) {
+        rootPath = nodePath.resolve(newRoot);
+    },
+    getApplicationPath: function () {
+        return nodePath.join(getPluginPath(), "..", "..", "..");
+    },
+    getAppJsonFile: function () {
+        return nodePath.join(this.getApplicationPath(), "app.json");
+    },
+    getPackageJsonFile: function () {
+        return nodePath.join(this.getApplicationPath(), "package.json");
+    },
+    getMetroSouceMapPath: function () {
+        return nodePath.join(this.getApplicationPath(), "node_modules", "metro", "src", "DeltaBundler", "Serializers", "helpers");
+    },
+    getOurSourceMapFile: function () {
+        return nodePath.join(getPluginPath(), "lib", "metro", "getSourceMapInfo.js");
+    },
+    getInternalPackageJsonFile: function () {
+        return nodePath.join(getPluginPath(), "package.json");
+    },
+    getDefaultConfig: function () {
+        return nodePath.join(getPluginPath(), PATH_FILES, "default.config.js");
+    },
+    getBuildPath: function () {
+        return nodePath.join(getPluginPath(), "build");
+    },
+    getConfigFilePath: function () {
+        return nodePath.join(this.getApplicationPath(), "dynatrace.config.js");
+    },
+    getAndroidFolder: function () {
+        return nodePath.join(this.getApplicationPath(), "android");
+    },
+    getAndroidGradleFile: function (androidFolder) {
+        return nodePath.join(androidFolder, "build.gradle");
+    },
+    getIOSFolder: function () {
+        return nodePath.join(this.getApplicationPath(), "ios");
+    },
+    getDynatraceGradleFile: function () {
+        return nodePath.join(getPluginPath(), PATH_FILES, "dynatrace.gradle");
+    },
+    getCurrentLogPath: function () {
+        return nodePath.join(getPluginPath(), PATH_LOGS, "currentLog.txt");
+    },
+    getLogPath: function () {
+        return nodePath.join(getPluginPath(), PATH_LOGS);
+    }
+};
+function getPluginPath() {
+    return nodePath.join(rootPath, "..");
+}

package/scripts/start.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const StartUtil_1 = require("./util/StartUtil");
+module.exports = (function () {
+    StartUtil_1.startArgumentsCheck();
+}());