@datadog/datadog-ci 0.17.4 → 0.17.7

package/dist/commands/synthetics/run-test.js

@@ -8,336 +8,152 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.removeUndefinedValues = exports.RunTestCommand = exports.DEFAULT_COMMAND_CONFIG = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-const clipanion_1 = require("clipanion");
-const deep_extend_1 = __importDefault(require("deep-extend"));
-const utils_1 = require("../../helpers/utils");
+exports.getDatadogHost = exports.getApiHelper = exports.getTestsList = exports.executeTests = void 0;
 const api_1 = require("./api");
-const interfaces_1 = require("./interfaces");
-const default_1 = require("./reporters/default");
-const junit_1 = require("./reporters/junit");
+const errors_1 = require("./errors");
 const tunnel_1 = require("./tunnel");
-const utils_2 = require("./utils");
-exports.DEFAULT_COMMAND_CONFIG = {
-    apiKey: '',
-    appKey: '',
-    configPath: 'datadog-ci.json',
-    datadogSite: 'datadoghq.com',
-    failOnCriticalErrors: false,
-    failOnTimeout: true,
-    files: ['{,!(node_modules)/**/}*.synthetics.json'],
-    global: {},
-    locations: [],
-    pollingTimeout: 2 * 60 * 1000,
-    proxy: { protocol: 'http' },
-    publicIds: [],
-    subdomain: 'app',
-    tunnel: false,
-};
-class RunTestCommand extends clipanion_1.Command {
-    constructor() {
-        super(...arguments);
-        this.config = JSON.parse(JSON.stringify(exports.DEFAULT_COMMAND_CONFIG)); // Deep copy to avoid mutation during unit tests
-    }
-    execute() {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const reporters = [new default_1.DefaultReporter(this)];
-            if (this.jUnitReport) {
-                reporters.push(new junit_1.JUnitReporter(this));
-            }
-            this.reporter = utils_2.getReporter(reporters);
-            yield this.resolveConfig();
-            const startTime = Date.now();
-            const api = this.getApiHelper();
-            const publicIdsFromCli = this.config.publicIds.map((id) => ({ suite: 'CLI Suite', config: this.config.global, id }));
-            let testsToTrigger;
-            let tunnel;
-            const safeExit = (exitCode) => __awaiter(this, void 0, void 0, function* () {
-                if (tunnel) {
-                    yield tunnel.stop();
-                }
-                return exitCode;
-            });
-            if (publicIdsFromCli.length) {
-                testsToTrigger = publicIdsFromCli;
-            }
-            else {
-                try {
-                    testsToTrigger = yield this.getTestsList(api);
-                }
-                catch (error) {
-                    this.reporter.error(`\n${chalk_1.default.bgRed.bold(' ERROR: unable to obtain test configurations with search query ')}\n${error.message}\n\n`);
-                    if (api_1.is5xxError(error) && !this.config.failOnCriticalErrors) {
-                        return safeExit(0);
-                    }
-                    return safeExit(1);
-                }
-            }
-            if (!testsToTrigger.length) {
-                this.reporter.log('No test suites to run.\n');
-                return safeExit(0);
-            }
-            let testsToTriggerResult;
-            try {
-                testsToTriggerResult = yield utils_2.getTestsToTrigger(api, testsToTrigger, this.reporter);
-            }
-            catch (error) {
-                this.reporter.error(`\n${chalk_1.default.bgRed.bold(' ERROR: unable to obtain test configurations ')}\n${error.message}\n\n`);
-                if (api_1.is5xxError(error) && !this.config.failOnCriticalErrors) {
-                    return safeExit(0);
-                }
-                return safeExit(1);
-            }
-            const { tests, overriddenTestsToTrigger, summary } = testsToTriggerResult;
-            // All tests have been skipped or are missing.
-            if (!tests.length) {
-                this.reporter.log('No test to run.\n');
-                return safeExit(0);
-            }
-            const publicIdsToTrigger = tests.map(({ public_id }) => public_id);
-            if (this.config.tunnel) {
-                this.reporter.log('You are using tunnel option, the chosen location(s) will be overridden by a location in your account region.\n');
-                let presignedURL;
-                try {
-                    // Get the pre-signed URL to connect to the tunnel service
-                    presignedURL = (yield api.getPresignedURL(publicIdsToTrigger)).url;
-                }
-                catch (e) {
-                    this.reporter.error(`\n${chalk_1.default.bgRed.bold(' ERROR: unable to get tunnel configuration')}\n${e.message}\n\n`);
-                    if (api_1.is5xxError(e) && !this.config.failOnCriticalErrors) {
-                        return safeExit(0);
-                    }
-                    return safeExit(1);
-                }
-                // Open a tunnel to Datadog
-                try {
-                    tunnel = new tunnel_1.Tunnel(presignedURL, publicIdsToTrigger, this.config.proxy, this.reporter);
-                    const tunnelInfo = yield tunnel.start();
-                    overriddenTestsToTrigger.forEach((testToTrigger) => {
-                        testToTrigger.tunnel = tunnelInfo;
-                    });
-                }
-                catch (e) {
-                    this.reporter.error(`\n${chalk_1.default.bgRed.bold(' ERROR: unable to start tunnel ')}\n${e.message}\n\n`);
-                    if (api_1.is5xxError(e) && !this.config.failOnCriticalErrors) {
-                        return safeExit(0);
-                    }
-                    return safeExit(1);
-                }
-            }
-            let triggers;
-            try {
-                triggers = yield utils_2.runTests(api, overriddenTestsToTrigger);
-            }
-            catch (e) {
-                this.reporter.error(`\n${chalk_1.default.bgRed.bold(' ERROR: unable to trigger tests ')}\n${e.message}\n\n`);
-                if (api_1.is5xxError(e) && !this.config.failOnCriticalErrors) {
-                    return safeExit(0);
-                }
-                return safeExit(1);
-            }
-            if (!triggers.results) {
-                throw new Error('No result to poll.');
-            }
-            const results = {};
-            try {
-                // Poll the results.
-                const resultPolled = yield utils_2.waitForResults(api, triggers.results, this.config.pollingTimeout, testsToTrigger, tunnel, this.config.failOnCriticalErrors);
-                Object.assign(results, resultPolled);
-            }
-            catch (error) {
-                this.reporter.error(`\n${chalk_1.default.bgRed.bold(' ERROR: unable to poll test results ')}\n${error.message}\n\n`);
-                if (api_1.is5xxError(error) && !this.config.failOnCriticalErrors) {
-                    return safeExit(0);
-                }
-                return safeExit(1);
-            }
-            // Sort tests to show success first then non blocking failures and finally blocking failures.
-            tests.sort(this.sortTestsByOutcome(results));
-            // Rendering the results.
-            this.reporter.reportStart({ startTime });
-            const locationNames = triggers.locations.reduce((mapping, location) => {
-                mapping[location.id] = location.display_name;
-                return mapping;
-            }, {});
-            let hasSucceeded = true; // Determine if all the tests have succeeded
-            for (const test of tests) {
-                const testResults = results[test.public_id];
-                if (!this.config.failOnTimeout) {
-                    if (!summary.timedOut) {
-                        summary.timedOut = 0;
-                    }
-                    const hasTimeout = testResults.some((pollResult) => pollResult.result.error === interfaces_1.ERRORS.TIMEOUT);
-                    if (hasTimeout) {
-                        summary.timedOut++;
-                    }
-                }
-                if (!this.config.failOnCriticalErrors) {
-                    if (!summary.criticalErrors) {
-                        summary.criticalErrors = 0;
-                    }
-                    const hasCriticalErrors = testResults.some((pollResult) => utils_2.isCriticalError(pollResult.result));
-                    if (hasCriticalErrors) {
-                        summary.criticalErrors++;
-                    }
-                }
-                const passed = utils_2.hasTestSucceeded(testResults, this.config.failOnCriticalErrors, this.config.failOnTimeout);
-                if (passed) {
-                    summary.passed++;
-                }
-                else {
-                    summary.failed++;
-                    if (((_a = test.options.ci) === null || _a === void 0 ? void 0 : _a.executionRule) !== interfaces_1.ExecutionRule.NON_BLOCKING) {
-                        hasSucceeded = false;
-                    }
-                }
-                this.reporter.testEnd(test, testResults, this.getAppBaseURL(), locationNames, this.config.failOnCriticalErrors, this.config.failOnTimeout);
-            }
-            this.reporter.runEnd(summary);
-            return safeExit(hasSucceeded ? 0 : 1);
-        });
+const utils_1 = require("./utils");
+const executeTests = (reporter, config) => __awaiter(void 0, void 0, void 0, function* () {
+    const api = exports.getApiHelper(config);
+    const publicIdsFromCli = config.publicIds.map((id) => ({ config: config.global, id }));
+    let testsToTrigger;
+    let tunnel;
+    const stopTunnel = () => __awaiter(void 0, void 0, void 0, function* () {
+        if (tunnel) {
+            yield tunnel.stop();
+        }
+    });
+    if (publicIdsFromCli.length) {
+        testsToTrigger = publicIdsFromCli;
     }
-    getApiHelper() {
-        if (!this.config.appKey || !this.config.apiKey) {
-            if (!this.config.appKey) {
-                this.reporter.error(`Missing ${chalk_1.default.red.bold('DATADOG_APP_KEY')} in your environment.\n`);
-            }
-            if (!this.config.apiKey) {
-                this.reporter.error(`Missing ${chalk_1.default.red.bold('DATADOG_API_KEY')} in your environment.\n`);
-            }
-            throw new Error('API and/or Application keys are missing');
+    else {
+        try {
+            testsToTrigger = yield exports.getTestsList(api, config, reporter);
         }
-        return api_1.apiConstructor({
-            apiKey: this.config.apiKey,
-            appKey: this.config.appKey,
-            baseIntakeUrl: this.getDatadogHost(true),
-            baseUrl: this.getDatadogHost(),
-            proxyOpts: this.config.proxy,
-        });
+        catch (error) {
+            const isCriticalError = api_1.is5xxError(error);
+            throw new (isCriticalError ? errors_1.CriticalError : errors_1.CiError)('UNAVAILABLE_TEST_CONFIG');
+        }
+    }
+    if (!testsToTrigger.length) {
+        throw new errors_1.CiError('NO_TESTS_TO_RUN');
+    }
+    let testsToTriggerResult;
+    try {
+        testsToTriggerResult = yield utils_1.getTestsToTrigger(api, testsToTrigger, reporter);
     }
-    getAppBaseURL() {
-        return `https://${this.config.subdomain}.${this.config.datadogSite}/`;
+    catch (error) {
+        const isCriticalError = api_1.is5xxError(error);
+        throw new (isCriticalError ? errors_1.CriticalError : errors_1.CiError)('UNAVAILABLE_TEST_CONFIG');
     }
-    getDatadogHost(useIntake = false) {
-        const apiPath = 'api/v1';
-        let host = `https://api.${this.config.datadogSite}`;
-        const hostOverride = process.env.DD_API_HOST_OVERRIDE;
-        if (hostOverride) {
-            host = hostOverride;
+    const { tests, overriddenTestsToTrigger, summary } = testsToTriggerResult;
+    // All tests have been skipped or are missing.
+    if (!tests.length) {
+        throw new errors_1.CiError('NO_TESTS_TO_RUN');
+    }
+    const publicIdsToTrigger = tests.map(({ public_id }) => public_id);
+    if (config.tunnel) {
+        let presignedURL;
+        try {
+            // Get the pre-signed URL to connect to the tunnel service
+            presignedURL = (yield api.getPresignedURL(publicIdsToTrigger)).url;
+        }
+        catch (error) {
+            const isCriticalError = api_1.is5xxError(error);
+            throw new (isCriticalError ? errors_1.CriticalError : errors_1.CiError)('UNAVAILABLE_TUNNEL_CONFIG');
         }
-        else if (useIntake &&
-            (this.config.datadogSite === 'datadoghq.com' || this.config.datadogSite === 'datad0g.com')) {
-            host = `https://intake.synthetics.${this.config.datadogSite}`;
+        // Open a tunnel to Datadog
+        try {
+            tunnel = new tunnel_1.Tunnel(presignedURL, publicIdsToTrigger, config.proxy, reporter);
+            const tunnelInfo = yield tunnel.start();
+            overriddenTestsToTrigger.forEach((testToTrigger) => {
+                testToTrigger.tunnel = tunnelInfo;
+            });
+        }
+        catch (error) {
+            const isCriticalError = api_1.is5xxError(error);
+            yield stopTunnel();
+            throw new (isCriticalError ? errors_1.CriticalError : errors_1.CiError)('TUNNEL_START_FAILED');
         }
-        return `${host}/${apiPath}`;
     }
-    getTestsList(api) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.config.testSearchQuery) {
-                const testSearchResults = yield api.searchTests(this.config.testSearchQuery);
-                return testSearchResults.tests.map((test) => ({
-                    config: this.config.global,
-                    id: test.public_id,
-                    suite: `Query: ${this.testSearchQuery}`,
-                }));
-            }
-            const suites = (yield Promise.all(this.config.files.map((glob) => utils_2.getSuites(glob, this.reporter))))
-                .reduce((acc, val) => acc.concat(val), [])
-                .filter((suite) => !!suite.content.tests);
-            const configFromEnvironment = ((_a = this.config.locations) === null || _a === void 0 ? void 0 : _a.length) ? { locations: this.config.locations } : {};
-            const testsToTrigger = suites
-                .map((suite) => suite.content.tests.map((test) => ({
-                config: Object.assign(Object.assign(Object.assign({}, this.config.global), configFromEnvironment), test.config),
-                id: test.id,
-                suite: suite.name,
-            })))
-                .reduce((acc, suiteTests) => acc.concat(suiteTests), []);
-            return testsToTrigger;
-        });
+    let triggers;
+    try {
+        triggers = yield utils_1.runTests(api, overriddenTestsToTrigger);
+    }
+    catch (error) {
+        const isCriticalError = api_1.is5xxError(error);
+        yield stopTunnel();
+        throw new (isCriticalError ? errors_1.CriticalError : errors_1.CiError)('TRIGGER_TESTS_FAILED');
+    }
+    if (!triggers.results) {
+        yield stopTunnel();
+        throw new errors_1.CriticalError('NO_RESULTS_TO_POLL');
+    }
+    const results = {};
+    try {
+        // Poll the results.
+        const resultPolled = yield utils_1.waitForResults(api, triggers.results, config.pollingTimeout, testsToTrigger, tunnel, config.failOnCriticalErrors);
+        Object.assign(results, resultPolled);
+    }
+    catch (error) {
+        const isCriticalError = api_1.is5xxError(error);
+        yield stopTunnel();
+        throw new (isCriticalError ? errors_1.CriticalError : errors_1.CiError)('POLL_RESULTS_FAILED');
     }
-    resolveConfig() {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            // Default < file < ENV < CLI
-            // Override with file config variables
-            try {
-                this.config = yield utils_1.parseConfigFile(this.config, (_a = this.configPath) !== null && _a !== void 0 ? _a : this.config.configPath);
-            }
-            catch (error) {
-                if (this.configPath) {
-                    throw error;
-                }
-            }
-            // Override with ENV variables
-            this.config = deep_extend_1.default(this.config, exports.removeUndefinedValues({
-                apiKey: process.env.DATADOG_API_KEY,
-                appKey: process.env.DATADOG_APP_KEY,
-                datadogSite: process.env.DATADOG_SITE,
-                locations: (_b = process.env.DATADOG_SYNTHETICS_LOCATIONS) === null || _b === void 0 ? void 0 : _b.split(';'),
-                subdomain: process.env.DATADOG_SUBDOMAIN,
-            }));
-            // Override with CLI parameters
-            this.config = deep_extend_1.default(this.config, exports.removeUndefinedValues({
-                apiKey: this.apiKey,
-                appKey: this.appKey,
-                configPath: this.configPath,
-                datadogSite: this.datadogSite,
-                failOnCriticalErrors: this.failOnCriticalErrors,
-                failOnTimeout: this.failOnTimeout,
-                files: this.files,
-                publicIds: this.publicIds,
-                subdomain: this.subdomain,
-                testSearchQuery: this.testSearchQuery,
-                tunnel: this.tunnel,
-            }));
-            if (typeof this.config.files === 'string') {
-                this.reporter.log('[DEPRECATED] "files" should be an array of string instead of a string.\n');
-                this.config.files = [this.config.files];
-            }
-        });
+    return { results, summary, tests, triggers };
+});
+exports.executeTests = executeTests;
+const getTestsList = (api, config, reporter) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    if (config.testSearchQuery) {
+        const testSearchResults = yield api.searchTests(config.testSearchQuery);
+        return testSearchResults.tests.map((test) => ({
+            config: config.global,
+            id: test.public_id,
+            suite: `Query: ${config.testSearchQuery}`,
+        }));
+    }
+    const suites = (yield Promise.all(config.files.map((glob) => utils_1.getSuites(glob, reporter))))
+        .reduce((acc, val) => acc.concat(val), [])
+        .filter((suite) => !!suite.content.tests);
+    const configFromEnvironment = ((_a = config.locations) === null || _a === void 0 ? void 0 : _a.length) ? { locations: config.locations } : {};
+    const testsToTrigger = suites
+        .map((suite) => suite.content.tests.map((test) => ({
+        config: Object.assign(Object.assign(Object.assign({}, config.global), configFromEnvironment), test.config),
+        id: test.id,
+        suite: suite.name,
+    })))
+        .reduce((acc, suiteTests) => acc.concat(suiteTests), []);
+    return testsToTrigger;
+});
+exports.getTestsList = getTestsList;
+const getApiHelper = (config) => {
+    if (!config.appKey) {
+        throw new errors_1.CiError('MISSING_APP_KEY');
+    }
+    if (!config.apiKey) {
+        throw new errors_1.CiError('MISSING_API_KEY');
+    }
+    return api_1.apiConstructor({
+        apiKey: config.apiKey,
+        appKey: config.appKey,
+        baseIntakeUrl: exports.getDatadogHost(true, config),
+        baseUrl: exports.getDatadogHost(false, config),
+        proxyOpts: config.proxy,
+    });
+};
+exports.getApiHelper = getApiHelper;
+const getDatadogHost = (useIntake = false, config) => {
+    const apiPath = 'api/v1';
+    let host = `https://api.${config.datadogSite}`;
+    const hostOverride = process.env.DD_API_HOST_OVERRIDE;
+    if (hostOverride) {
+        host = hostOverride;
     }
-    sortTestsByOutcome(results) {
-        return (t1, t2) => {
-            var _a, _b;
-            const success1 = utils_2.hasTestSucceeded(results[t1.public_id], this.config.failOnCriticalErrors, this.config.failOnTimeout);
-            const success2 = utils_2.hasTestSucceeded(results[t2.public_id], this.config.failOnCriticalErrors, this.config.failOnTimeout);
-            const isNonBlockingTest1 = ((_a = t1.options.ci) === null || _a === void 0 ? void 0 : _a.executionRule) === interfaces_1.ExecutionRule.NON_BLOCKING;
-            const isNonBlockingTest2 = ((_b = t2.options.ci) === null || _b === void 0 ? void 0 : _b.executionRule) === interfaces_1.ExecutionRule.NON_BLOCKING;
-            if (success1 === success2) {
-                if (isNonBlockingTest1 === isNonBlockingTest2) {
-                    return 0;
-                }
-                return isNonBlockingTest1 ? -1 : 1;
-            }
-            return success1 ? -1 : 1;
-        };
+    else if (useIntake && (config.datadogSite === 'datadoghq.com' || config.datadogSite === 'datad0g.com')) {
+        host = `https://intake.synthetics.${config.datadogSite}`;
     }
-}
-exports.RunTestCommand = RunTestCommand;
-const removeUndefinedValues = (object) => {
-    const newObject = Object.assign({}, object);
-    Object.keys(newObject).forEach((k) => newObject[k] === undefined && delete newObject[k]);
-    return newObject;
+    return `${host}/${apiPath}`;
 };
-exports.removeUndefinedValues = removeUndefinedValues;
-RunTestCommand.addPath('synthetics', 'run-tests');
-RunTestCommand.addOption('apiKey', clipanion_1.Command.String('--apiKey'));
-RunTestCommand.addOption('appKey', clipanion_1.Command.String('--appKey'));
-RunTestCommand.addOption('failOnCriticalErrors', clipanion_1.Command.Boolean('--failOnCriticalErrors'));
-RunTestCommand.addOption('configPath', clipanion_1.Command.String('--config'));
-RunTestCommand.addOption('datadogSite', clipanion_1.Command.String('--datadogSite'));
-RunTestCommand.addOption('files', clipanion_1.Command.Array('-f,--files'));
-RunTestCommand.addOption('failOnTimeout', clipanion_1.Command.Boolean('--failOnTimeout'));
-RunTestCommand.addOption('publicIds', clipanion_1.Command.Array('-p,--public-id'));
-RunTestCommand.addOption('testSearchQuery', clipanion_1.Command.String('-s,--search'));
-RunTestCommand.addOption('subdomain', clipanion_1.Command.Boolean('--subdomain'));
-RunTestCommand.addOption('tunnel', clipanion_1.Command.Boolean('-t,--tunnel'));
-RunTestCommand.addOption('jUnitReport', clipanion_1.Command.String('-j,--jUnitReport'));
-RunTestCommand.addOption('runName', clipanion_1.Command.String('-n,--runName'));
+exports.getDatadogHost = getDatadogHost;

package/dist/commands/synthetics/tunnel.d.ts

@@ -0,0 +1,43 @@
+import { ProxyConfiguration } from '../../helpers/utils';
+import { MainReporter } from './interfaces';
+export interface TunnelInfo {
+    host: string;
+    id: string;
+    privateKey: string;
+}
+export declare class Tunnel {
+    private url;
+    private testIDs;
+    private connected;
+    private forwardedSockets;
+    private FORWARDING_TIMEOUT;
+    private log;
+    private logError;
+    private logWarning;
+    private multiplexer?;
+    private privateKey;
+    private publicKey;
+    private sshConfig;
+    private ws;
+    constructor(url: string, testIDs: string[], proxy: ProxyConfiguration, reporter: MainReporter);
+    /**
+     * keepAlive will return a promise that tracks the state of the tunnel (and reject in case of error)
+     */
+    keepAlive(): Promise<void>;
+    /**
+     * start the tunnel:
+     *   - get the pre-signed URL to connect to the tunnel service
+     *   - Set up SSH
+     *   - establish a WebSocket connection to the tunnel service
+     */
+    start(): Promise<TunnelInfo>;
+    /**
+     * stop the tunnel
+     */
+    stop(): Promise<void>;
+    private authenticateSSHConnection;
+    private forwardProxiedPacketsFromSSH;
+    private forwardWebSocketToSSH;
+    private getConnectionInfo;
+    private processSSHStream;
+}

package/dist/commands/synthetics/utils.d.ts

@@ -0,0 +1,26 @@
+import { APIHelper, ConfigOverride, ExecutionRule, InternalTest, MainReporter, PollResult, Reporter, Result, Suite, Summary, TestPayload, Trigger, TriggerConfig, TriggerResponse, TriggerResult } from './interfaces';
+import { Tunnel } from './tunnel';
+export declare const handleConfig: (test: InternalTest, publicId: string, reporter: MainReporter, config?: ConfigOverride | undefined) => TestPayload;
+export declare const getExecutionRule: (test: InternalTest, configOverride?: ConfigOverride | undefined) => ExecutionRule;
+export declare const getStrictestExecutionRule: (configRule: ExecutionRule, testRule?: ExecutionRule | undefined) => ExecutionRule;
+export declare const isCriticalError: (result: Result) => boolean;
+export declare const hasResultPassed: (result: Result, failOnCriticalErrors: boolean, failOnTimeout: boolean) => boolean;
+export declare const hasTestSucceeded: (results: PollResult[], failOnCriticalErrors: boolean, failOnTimeout: boolean) => boolean;
+export declare const getSuites: (GLOB: string, reporter: MainReporter) => Promise<Suite[]>;
+export declare const wait: (duration: number) => Promise<unknown>;
+export declare const waitForResults: (api: APIHelper, triggerResponses: TriggerResponse[], defaultTimeout: number, triggerConfigs: TriggerConfig[], tunnel?: Tunnel | undefined, failOnCriticalErrors?: boolean | undefined) => Promise<{
+    [key: string]: PollResult[];
+}>;
+export declare const createTriggerResultMap: (triggerResponses: TriggerResponse[], defaultTimeout: number, triggerConfigs: TriggerConfig[]) => Map<string, TriggerResult>;
+export declare const getResultDuration: (result: Result) => number;
+export declare const getReporter: (reporters: Reporter[]) => MainReporter;
+export declare const getTestsToTrigger: (api: APIHelper, triggerConfigs: TriggerConfig[], reporter: MainReporter) => Promise<{
+    tests: InternalTest[];
+    overriddenTestsToTrigger: TestPayload[];
+    summary: Summary;
+}>;
+export declare const runTests: (api: APIHelper, testsToTrigger: TestPayload[]) => Promise<Trigger>;
+export declare const retry: <T, E extends Error>(func: () => Promise<T>, shouldRetryAfterWait: (retries: number, error: E) => number | undefined) => Promise<T>;
+export declare const removeUndefinedValues: <T extends {
+    [key: string]: any;
+}>(object: T) => T;

package/dist/commands/synthetics/utils.js

@@ -31,7 +31,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.retry = exports.runTests = exports.getTestsToTrigger = exports.getReporter = exports.getResultDuration = exports.createTriggerResultMap = exports.waitForResults = exports.wait = exports.getSuites = exports.hasTestSucceeded = exports.hasResultPassed = exports.isCriticalError = exports.getStrictestExecutionRule = exports.getExecutionRule = exports.handleConfig = void 0;
+exports.removeUndefinedValues = exports.retry = exports.runTests = exports.getTestsToTrigger = exports.getReporter = exports.getResultDuration = exports.createTriggerResultMap = exports.waitForResults = exports.wait = exports.getSuites = exports.hasTestSucceeded = exports.hasResultPassed = exports.isCriticalError = exports.getStrictestExecutionRule = exports.getExecutionRule = exports.handleConfig = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const url_1 = require("url");
@@ -426,3 +426,13 @@ const retry = (func, shouldRetryAfterWait) => __awaiter(void 0, void 0, void 0,
     return trier();
 });
 exports.retry = retry;
+const removeUndefinedValues = (object) => {
+    const newObject = Object.assign({}, object);
+    for (const [key, value] of Object.entries(newObject)) {
+        if (value === undefined) {
+            delete newObject[key];
+        }
+    }
+    return newObject;
+};
+exports.removeUndefinedValues = removeUndefinedValues;

package/dist/commands/synthetics/websocket.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { default as WebSocketModule } from 'ws';
+import { ProxyConfiguration } from '../../helpers/utils';
+export declare class WebSocket extends EventEmitter {
+    private url;
+    private proxyOpts;
+    private firstMessage?;
+    private keepAliveWebsocket?;
+    private websocket?;
+    constructor(url: string, proxyOpts: ProxyConfiguration);
+    /**
+     * close will terminate the WebSocket connection
+     */
+    close(gracefullyClose?: boolean): Promise<void>;
+    /**
+     * connect will start a WebSocket connection
+     */
+    connect(): Promise<void>;
+    /**
+     * duplex will create a duplex stream for the WS connection
+     */
+    duplex(): import("stream").Duplex;
+    /**
+     * keepAlive will return a promise to keep track of the tunnel connection
+     */
+    keepAlive(): Promise<void>;
+    /**
+     * on allows to listen for WebSocket messages
+     */
+    on(event: 'message', listener: (data: WebSocketModule.Data) => void): this;
+    /**
+     * once allows to listen for a WebSocket message
+     */
+    once(event: 'message', listener: (data: WebSocketModule.Data) => void): this;
+    waitForFirstMessage(): Promise<WebSocketModule.Data>;
+    private establishWebsocketConnection;
+}

package/dist/commands/trace/__tests__/trace.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/trace/api.d.ts

@@ -0,0 +1,6 @@
+import type { AxiosPromise, AxiosRequestConfig, AxiosResponse } from 'axios';
+import { Payload } from './interfaces';
+export declare const reportCustomSpan: (request: (args: AxiosRequestConfig) => AxiosPromise<AxiosResponse>) => (customSpan: Payload, provider: string) => Promise<AxiosResponse<AxiosResponse<any>>>;
+export declare const apiConstructor: (baseUrl: string, apiKey: string) => {
+    reportCustomSpan: (customSpan: Payload, provider: string) => Promise<AxiosResponse<AxiosResponse<any>>>;
+};

package/dist/commands/trace/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/trace/interfaces.d.ts

@@ -0,0 +1,23 @@
+import { AxiosPromise, AxiosResponse } from 'axios';
+export declare const CIRCLECI = "circleci";
+export declare const JENKINS = "jenkins";
+export declare const SUPPORTED_PROVIDERS: readonly ["circleci", "jenkins"];
+export declare type Provider = typeof SUPPORTED_PROVIDERS[number];
+export interface Payload {
+    command: string;
+    custom: {
+        id: string;
+        parent_id?: string;
+    };
+    data: Record<string, string>;
+    end_time: string;
+    error_message: string;
+    exit_code: number;
+    is_error: boolean;
+    name: string;
+    start_time: string;
+    tags: Partial<Record<string, string>>;
+}
+export interface APIHelper {
+    reportCustomSpan(customSpan: Payload, provider: Provider): AxiosPromise<AxiosResponse>;
+}