@elastic/synthetics 1.14.0 → 1.16.0

package/dist/core/runner.d.ts

@@ -23,51 +23,42 @@
  *
  */
 import { Journey } from '../dsl/journey';
-import { Step } from '../dsl/step';
-import { HooksCallback, Params, HooksArgs, Driver, RunOptions, JourneyResult, StepResult, PushOptions } from '../common_types';
-import { PluginManager } from '../plugins';
+import { HooksCallback, RunOptions, JourneyResult, PushOptions } from '../common_types';
 import { Monitor, MonitorConfig } from '../dsl/monitor';
 type HookType = 'beforeAll' | 'afterAll';
 export type SuiteHooks = Record<HookType, Array<HooksCallback>>;
-type JourneyContext = {
-    params?: Params;
-    browserDelay: number;
-    start: number;
-    driver: Driver;
-    pluginManager: PluginManager;
-};
 type RunResult = Record<string, JourneyResult>;
-export default class Runner {
-    #private;
-    journeys: Journey[];
-    hooks: SuiteHooks;
-    hookError: Error | undefined;
-    monitor?: Monitor;
-    static screenshotPath: string;
-    static createContext(options: RunOptions): Promise<JourneyContext>;
-    captureScreenshot(page: Driver['page'], step: Step): Promise<void>;
-    get currentJourney(): Journey;
-    addHook(type: HookType, callback: HooksCallback): void;
-    updateMonitor(config: MonitorConfig): void;
-    addJourney(journey: Journey): void;
-    setReporter(options: RunOptions): void;
-    runBeforeAllHook(args: HooksArgs): Promise<void>;
-    runAfterAllHook(args: HooksArgs): Promise<void>;
-    runBeforeHook(journey: Journey, args: HooksArgs): Promise<void>;
-    runAfterHook(journey: Journey, args: HooksArgs): Promise<void>;
-    runStep(step: Step, context: JourneyContext, options: RunOptions): Promise<StepResult>;
-    runSteps(journey: Journey, context: JourneyContext, options: RunOptions): Promise<StepResult[]>;
-    registerJourney(journey: Journey, context: JourneyContext): void;
-    endJourney(journey: any, result: JourneyContext & JourneyResult, options: RunOptions): Promise<void>;
+export interface RunnerInfo {
+    /**
+     * Processed configuration from the CLI args and the config file
+     */
+    readonly config: RunOptions;
     /**
-     * Simulate a journey run to capture errors in the beforeAll hook
+     * Currently active journey
      */
-    runFakeJourney(journey: Journey, options: RunOptions): Promise<JourneyResult>;
-    runJourney(journey: Journey, options: RunOptions): Promise<JourneyResult>;
-    init(options: RunOptions): Promise<void>;
-    buildMonitors(options: PushOptions): Monitor[];
-    run(options: RunOptions): Promise<RunResult>;
-    reset(): Promise<void>;
+    readonly journey: Journey | undefined;
+    /**
+     * All registerd journeys
+     */
+    readonly journeys: Journey[];
+}
+export default class Runner implements RunnerInfo {
+    #private;
+    config: RunOptions;
+    get journey(): Journey;
+    get journeys(): Journey[];
+    get hooks(): SuiteHooks;
+    private captureScreenshot;
+    _addHook(type: HookType, callback: HooksCallback): void;
+    private buildHookArgs;
+    _updateMonitor(config: MonitorConfig): void;
+    _addJourney(journey: Journey): void;
+    private setReporter;
+    _runJourney(journey: Journey, options: RunOptions): Promise<JourneyResult>;
+    _buildMonitors(options: PushOptions): Monitor[];
+    _run(options: RunOptions): Promise<RunResult>;
+    _runJourneys(options: RunOptions): Promise<RunResult>;
+    _reset(): Promise<void>;
 }
 export {};
 //# sourceMappingURL=runner.d.ts.map

package/dist/core/runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/core/runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AASnC,OAAO,EACL,aAAa,EACb,MAAM,EACN,SAAS,EACT,MAAM,EAEN,UAAU,EACV,aAAa,EACb,UAAU,EACV,WAAW,EACZ,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,aAAa,EAGd,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAExD,KAAK,QAAQ,GAAG,WAAW,GAAG,UAAU,CAAC;AACzC,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,QAAQ,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC;AAEhE,KAAK,cAAc,GAAG;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,aAAa,CAAC;CAC9B,CAAC;AAEF,KAAK,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AAE/C,MAAM,CAAC,OAAO,OAAO,MAAM;;IAIzB,QAAQ,EAAE,OAAO,EAAE,CAAM;IACzB,KAAK,EAAE,UAAU,CAAmC;IACpD,SAAS,EAAE,KAAK,GAAG,SAAS,CAAC;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,cAAc,SAAmC;WAE3C,aAAa,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,cAAc,CAAC;IAuBlE,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,IAAI;IA6BxD,IAAI,cAAc,YAEjB;IAED,OAAO,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa;IAI/C,aAAa,CAAC,MAAM,EAAE,aAAa;IAQnC,UAAU,CAAC,OAAO,EAAE,OAAO;IAK3B,WAAW,CAAC,OAAO,EAAE,UAAU;IAazB,gBAAgB,CAAC,IAAI,EAAE,SAAS;IAKhC,eAAe,CAAC,IAAI,EAAE,SAAS;IAK/B,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS;IAK/C,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS;IAK9C,OAAO,CACX,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE,UAAU,GAClB,OAAO,CAAC,UAAU,CAAC;IAkEhB,QAAQ,CACZ,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE,UAAU;IAyCrB,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc;IAcnD,UAAU,CACd,OAAO,KAAA,EACP,MAAM,EAAE,cAAc,GAAG,aAAa,EACtC,OAAO,EAAE,UAAU;IAuBrB;;OAEG;IACG,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU;IAqBpD,UAAU,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU;IAkChD,IAAI,CAAC,OAAO,EAAE,UAAU;IAY9B,aAAa,CAAC,OAAO,EAAE,WAAW;IAkD5B,GAAG,CAAC,OAAO,EAAE,UAAU;IA+CvB,KAAK;CAWZ"}
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/core/runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAUzC,OAAO,EACL,aAAa,EAIb,UAAU,EACV,aAAa,EAEb,WAAW,EACZ,MAAM,iBAAiB,CAAC;AAOzB,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAExD,KAAK,QAAQ,GAAG,WAAW,GAAG,UAAU,CAAC;AACzC,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,QAAQ,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC;AAEhE,KAAK,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AAE/C,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,CAAC;IACtC;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,EAAE,CAAC;CAC9B;AAED,MAAM,CAAC,OAAO,OAAO,MAAO,YAAW,UAAU;;IAW/C,MAAM,EAAE,UAAU,CAAC;IAEnB,IAAI,OAAO,YAEV;IAED,IAAI,QAAQ,cAEX;IAED,IAAI,KAAK,eAER;YAEa,iBAAiB;IA6B/B,QAAQ,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa;IAIhD,OAAO,CAAC,aAAa;IAIrB,cAAc,CAAC,MAAM,EAAE,aAAa;IAQpC,WAAW,CAAC,OAAO,EAAE,OAAO;IAK5B,OAAO,CAAC,WAAW;IAiNb,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU;IAmCvD,cAAc,CAAC,OAAO,EAAE,WAAW;IA+D7B,IAAI,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC;IAiC7C,YAAY,CAAC,OAAO,EAAE,UAAU;IAgBhC,MAAM;CAWb"}

package/dist/core/runner.js

@@ -36,32 +36,22 @@ class Runner {
     #active = false;
     #reporter;
     #currentJourney = null;
-    journeys = [];
-    hooks = { beforeAll: [], afterAll: [] };
-    hookError;
-    monitor;
-    static screenshotPath = (0, path_1.join)(helpers_1.CACHE_PATH, 'screenshots');
-    static async createContext(options) {
-        const browserStart = (0, helpers_1.monotonicTimeInSeconds)();
-        const driver = await gatherer_1.Gatherer.setupDriver(options);
-        /**
-         * Do not include browser launch/context creation duration
-         * as part of journey duration
-         */
-        const start = (0, helpers_1.monotonicTimeInSeconds)();
-        const pluginManager = await gatherer_1.Gatherer.beginRecording(driver, options);
-        /**
-         * For each journey we create the screenshots folder for
-         * caching all screenshots and clear them at end of each journey
-         */
-        await (0, promises_1.mkdir)(this.screenshotPath, { recursive: true });
-        return {
-            start,
-            browserDelay: start - browserStart,
-            params: options.params,
-            driver,
-            pluginManager,
-        };
+    #journeys = [];
+    #hooks = { beforeAll: [], afterAll: [] };
+    #screenshotPath = (0, path_1.join)(helpers_1.CACHE_PATH, 'screenshots');
+    #driver;
+    #browserDelay = -1;
+    #hookError;
+    #monitor;
+    config;
+    get journey() {
+        return this.#currentJourney;
+    }
+    get journeys() {
+        return this.#journeys;
+    }
+    get hooks() {
+        return this.#hooks;
     }
     async captureScreenshot(page, step) {
         try {
@@ -81,7 +71,7 @@ class Runner {
                 timestamp: (0, helpers_1.getTimestamp)(),
                 data: buffer.toString('base64'),
             };
-            await (0, promises_1.writeFile)((0, path_1.join)(Runner.screenshotPath, fileName), JSON.stringify(screenshot));
+            await (0, promises_1.writeFile)((0, path_1.join)(this.#screenshotPath, fileName), JSON.stringify(screenshot));
             (0, logger_1.log)(`Runner: captured screenshot for (${step.name})`);
         }
         catch (_) {
@@ -89,21 +79,21 @@ class Runner {
             (0, logger_1.log)(`Runner: failed to capture screenshot for (${step.name})`);
         }
     }
-    get currentJourney() {
-        return this.#currentJourney;
+    _addHook(type, callback) {
+        this.#hooks[type].push(callback);
     }
-    addHook(type, callback) {
-        this.hooks[type].push(callback);
+    buildHookArgs() {
+        return { env: this.config.environment, params: this.config.params, info: this };
     }
-    updateMonitor(config) {
-        if (!this.monitor) {
-            this.monitor = new monitor_1.Monitor(config);
+    _updateMonitor(config) {
+        if (!this.#monitor) {
+            this.#monitor = new monitor_1.Monitor(config);
             return;
         }
-        this.monitor.update(config);
+        this.#monitor.update(config);
     }
-    addJourney(journey) {
-        this.journeys.push(journey);
+    _addJourney(journey) {
+        this.#journeys.push(journey);
         this.#currentJourney = journey;
     }
     setReporter(options) {
@@ -117,66 +107,64 @@ class Runner {
             : reporters_1.reporters[reporter] || reporters_1.reporters['default'];
         this.#reporter = new Reporter({ fd: outfd, dryRun });
     }
-    async runBeforeAllHook(args) {
+    async #runBeforeAllHook(args) {
         (0, logger_1.log)(`Runner: beforeAll hooks`);
-        await (0, helpers_1.runParallel)(this.hooks.beforeAll, args);
+        await (0, helpers_1.runParallel)(this.#hooks.beforeAll, args);
     }
-    async runAfterAllHook(args) {
+    async #runAfterAllHook(args) {
         (0, logger_1.log)(`Runner: afterAll hooks`);
-        await (0, helpers_1.runParallel)(this.hooks.afterAll, args);
+        await (0, helpers_1.runParallel)(this.#hooks.afterAll, args);
     }
-    async runBeforeHook(journey, args) {
+    async #runBeforeHook(journey, args) {
         (0, logger_1.log)(`Runner: before hooks for (${journey.name})`);
-        await (0, helpers_1.runParallel)(journey.hooks.before, args);
+        await (0, helpers_1.runParallel)(journey._getHook('before'), args);
     }
-    async runAfterHook(journey, args) {
+    async #runAfterHook(journey, args) {
         (0, logger_1.log)(`Runner: after hooks for (${journey.name})`);
-        await (0, helpers_1.runParallel)(journey.hooks.after, args);
+        await (0, helpers_1.runParallel)(journey._getHook('after'), args);
     }
-    async runStep(step, context, options) {
-        const data = {
-            status: 'succeeded',
-        };
+    async #runStep(step, options) {
         (0, logger_1.log)(`Runner: start step (${step.name})`);
         const { metrics, screenshots, filmstrips, trace } = options;
-        const { driver, pluginManager } = context;
         /**
          * URL needs to be the first navigation request of any step
          * Listening for request solves the case where `about:blank` would be
          * reported for failed navigations
          */
         const captureUrl = req => {
-            if (!data.url && req.isNavigationRequest()) {
-                data.url = req.url();
+            if (!step.url && req.isNavigationRequest()) {
+                step.url = req.url();
             }
-            driver.context.off('request', captureUrl);
+            this.#driver.context.off('request', captureUrl);
         };
-        driver.context.on('request', captureUrl);
+        this.#driver.context.on('request', captureUrl);
+        const data = {};
         const traceEnabled = trace || filmstrips;
         try {
             /**
              * Set up plugin manager context and also register
              * step level plugins
              */
-            pluginManager.onStep(step);
-            traceEnabled && (await pluginManager.start('trace'));
+            gatherer_1.Gatherer.pluginManager.onStep(step);
+            traceEnabled && (await gatherer_1.Gatherer.pluginManager.start('trace'));
             // invoke the step callback by extracting to a variable to get better stack trace
-            const cb = step.callback;
+            const cb = step.cb;
             await cb();
+            step.status = "succeeded";
         }
         catch (error) {
-            data.status = 'failed';
-            data.error = error;
+            step.status = 'failed';
+            step.error = error;
         }
         finally {
             /**
              * Collect all step level metrics and trace events
              */
             if (metrics) {
-                data.pagemetrics = await pluginManager.get('performance').getMetrics();
+                data.pagemetrics = await gatherer_1.Gatherer.pluginManager.get('performance').getMetrics();
             }
             if (traceEnabled) {
-                const traceOutput = await pluginManager.stop('trace');
+                const traceOutput = await gatherer_1.Gatherer.pluginManager.stop('trace');
                 Object.assign(data, traceOutput);
             }
             /**
@@ -185,10 +173,10 @@ class Runner {
              *
              * Last open page will get us the correct screenshot
              */
-            const pages = driver.context.pages();
+            const pages = this.#driver.context.pages();
             const page = pages[pages.length - 1];
             if (page) {
-                data.url ??= page.url();
+                step.url ??= page.url();
                 if (screenshots && screenshots !== 'off') {
                     await this.captureScreenshot(page, step);
                 }
@@ -197,14 +185,14 @@ class Runner {
         (0, logger_1.log)(`Runner: end step (${step.name})`);
         return data;
     }
-    async runSteps(journey, context, options) {
+    async #runSteps(journey, options) {
         const results = [];
         const isOnlyExists = journey.steps.filter(s => s.only).length > 0;
         let skipStep = false;
         for (const step of journey.steps) {
-            const start = (0, helpers_1.monotonicTimeInSeconds)();
+            step._startTime = (0, helpers_1.monotonicTimeInSeconds)();
             this.#reporter?.onStepStart?.(journey, step);
-            let data = { status: 'succeeded' };
+            let data = {};
             /**
              * Skip the step
              * - if the step is marked as skip
@@ -214,133 +202,126 @@ class Runner {
             if (step.skip ||
                 (skipStep && !step.only) ||
                 (isOnlyExists && !step.only)) {
-                data.status = 'skipped';
+                step.status = 'skipped';
             }
             else {
-                data = await this.runStep(step, context, options);
+                data = await this.#runStep(step, options);
                 /**
                  * skip next steps if the previous step returns error
                  */
-                if (data.error && !step.soft)
+                if (step.error && !step.soft)
                     skipStep = true;
             }
-            this.#reporter?.onStepEnd?.(journey, step, {
-                start,
-                end: (0, helpers_1.monotonicTimeInSeconds)(),
-                ...data,
-            });
-            if (options.pauseOnError && data.error) {
+            step.duration = (0, helpers_1.monotonicTimeInSeconds)() - step._startTime;
+            this.#reporter?.onStepEnd?.(journey, step, data);
+            if (options.pauseOnError && step.error) {
                 await new Promise(r => process.stdin.on('data', r));
             }
             results.push(data);
         }
         return results;
     }
-    registerJourney(journey, context) {
-        this.#currentJourney = journey;
-        const timestamp = (0, helpers_1.getTimestamp)();
-        const { params } = context;
+    async #startJourney(journey, options) {
+        journey._startTime = (0, helpers_1.monotonicTimeInSeconds)();
+        this.#driver = await gatherer_1.Gatherer.setupDriver(options);
+        await gatherer_1.Gatherer.beginRecording(this.#driver, options);
+        /**
+         * For each journey we create the screenshots folder for
+         * caching all screenshots and clear them at end of each journey
+         */
+        await (0, promises_1.mkdir)(this.#screenshotPath, { recursive: true });
+        const params = options.params;
         this.#reporter?.onJourneyStart?.(journey, {
-            timestamp,
+            timestamp: (0, helpers_1.getTimestamp)(),
             params,
         });
         /**
          * Exeucute the journey callback which registers the steps for current journey
          */
-        journey.callback({ ...context.driver, params });
+        journey.cb({ ...this.#driver, params, info: this });
     }
-    async endJourney(journey, result, options) {
-        const end = (0, helpers_1.monotonicTimeInSeconds)();
-        const { pluginManager, start, status, error, browserDelay } = result;
-        const pluginOutput = await pluginManager.output();
+    async #endJourney(journey, result, options) {
+        // Enhance the journey results
+        const pOutput = await gatherer_1.Gatherer.pluginManager.output();
+        const bConsole = (0, plugins_1.filterBrowserMessages)(pOutput.browserconsole, journey.status);
         await this.#reporter?.onJourneyEnd?.(journey, {
-            status,
-            error,
-            start,
-            end,
-            browserDelay,
+            browserDelay: this.#browserDelay,
             timestamp: (0, helpers_1.getTimestamp)(),
             options,
-            ...pluginOutput,
-            browserconsole: (0, plugins_1.filterBrowserMessages)(pluginOutput.browserconsole, status),
+            networkinfo: pOutput.networkinfo,
+            browserconsole: bConsole,
         });
+        await gatherer_1.Gatherer.endRecording();
+        await gatherer_1.Gatherer.dispose(this.#driver);
         // clear screenshots cache after each journey
-        await (0, promises_1.rm)(Runner.screenshotPath, { recursive: true, force: true });
+        await (0, promises_1.rm)(this.#screenshotPath, { recursive: true, force: true });
+        return Object.assign(result, {
+            networkinfo: pOutput.networkinfo,
+            browserconsole: bConsole,
+            ...journey,
+        });
     }
     /**
      * Simulate a journey run to capture errors in the beforeAll hook
      */
-    async runFakeJourney(journey, options) {
+    async #runFakeJourney(journey, options) {
         const start = (0, helpers_1.monotonicTimeInSeconds)();
         this.#reporter.onJourneyStart?.(journey, {
             timestamp: (0, helpers_1.getTimestamp)(),
             params: options.params,
         });
-        const result = {
-            status: 'failed',
-            error: this.hookError,
-        };
+        // Mark the journey as failed and report the hook error as journey error
+        journey.status = 'failed';
+        journey.error = this.#hookError;
+        journey.duration = (0, helpers_1.monotonicTimeInSeconds)() - start;
         await this.#reporter.onJourneyEnd?.(journey, {
             timestamp: (0, helpers_1.getTimestamp)(),
-            start,
             options,
-            browserDelay: 0,
-            end: (0, helpers_1.monotonicTimeInSeconds)(),
-            ...result,
+            browserDelay: this.#browserDelay,
         });
-        return result;
+        return journey;
     }
-    async runJourney(journey, options) {
-        const result = { status: 'succeeded' };
-        const context = await Runner.createContext(options);
+    async _runJourney(journey, options) {
+        this.#currentJourney = journey;
         (0, logger_1.log)(`Runner: start journey (${journey.name})`);
+        let result = {};
+        const hookArgs = { env: options.environment, params: options.params, info: this };
         try {
-            this.registerJourney(journey, context);
-            const hookArgs = {
-                env: options.environment,
-                params: options.params,
-            };
-            await this.runBeforeHook(journey, hookArgs);
-            const stepResults = await this.runSteps(journey, context, options);
-            /**
-             * Mark journey as failed if any intermediate step fails
-             */
-            for (const stepResult of stepResults) {
-                if (stepResult.status === 'failed') {
-                    result.status = stepResult.status;
-                    result.error = stepResult.error;
+            await this.#startJourney(journey, options);
+            await this.#runBeforeHook(journey, hookArgs);
+            const stepResults = await this.#runSteps(journey, options);
+            journey.status = "succeeded";
+            // Mark journey as failed if any one of the step fails
+            for (const step of journey.steps) {
+                if (step.status === 'failed') {
+                    journey.status = step.status;
+                    journey.error = step.error;
                 }
             }
-            result.steps = stepResults;
-            await this.runAfterHook(journey, hookArgs);
+            result.stepsresults = stepResults;
         }
         catch (e) {
-            result.status = 'failed';
-            result.error = e;
+            journey.status = 'failed';
+            journey.error = e;
         }
         finally {
-            await this.endJourney(journey, { ...context, ...result }, options);
-            await gatherer_1.Gatherer.dispose(context.driver);
+            journey.duration = (0, helpers_1.monotonicTimeInSeconds)() - journey._startTime;
+            // Run after hook on journey failure and capture the uncaught error as
+            // journey error, hook is purposely run before to capture errors during reporting
+            await this.#runAfterHook(journey, hookArgs).catch(e => {
+                journey.status = 'failed';
+                journey.error = e;
+            });
+            result = await this.#endJourney(journey, result, options);
         }
         (0, logger_1.log)(`Runner: end journey (${journey.name})`);
         return result;
     }
-    async init(options) {
-        this.setReporter(options);
-        this.#reporter.onStart?.({
-            numJourneys: this.journeys.length,
-            networkConditions: options.networkConditions,
-        });
-        /**
-         * Set up the directory for caching screenshots
-         */
-        await (0, promises_1.mkdir)(helpers_1.CACHE_PATH, { recursive: true });
-    }
-    buildMonitors(options) {
+    _buildMonitors(options) {
         /**
          * Update the global monitor configuration required for setting defaults
          */
-        this.updateMonitor({
+        this._updateMonitor({
             throttling: options.throttling,
             schedule: options.schedule,
             locations: options.locations,
@@ -354,7 +335,7 @@ class Runner {
             enabled: options.enabled,
         });
         const monitors = [];
-        for (const journey of this.journeys) {
+        for (const journey of this.#journeys) {
             this.#currentJourney = journey;
             if (journey.skip) {
                 throw new Error(`Journey ${journey.name} is skipped. Please remove the journey.skip annotation and try again.`);
@@ -367,63 +348,77 @@ class Runner {
              * - filter out monitors based on matched tags and name after applying both
              *  global and local monitor configurations
              */
-            journey.callback({ params: options.params });
-            journey.monitor.update(this.monitor?.config);
-            if (!journey.monitor.isMatch(options.grepOpts?.match, options.grepOpts?.tags)) {
+            journey.cb({ params: options.params });
+            const monitor = journey._getMonitor();
+            monitor.update(this.#monitor?.config);
+            if (!monitor.isMatch(options.grepOpts?.match, options.grepOpts?.tags)) {
                 continue;
             }
-            journey.monitor.validate();
-            monitors.push(journey.monitor);
+            monitor.validate();
+            monitors.push(monitor);
         }
         return monitors;
     }
-    async run(options) {
-        const result = {};
+    async #init(options) {
+        this.setReporter(options);
+        this.#reporter.onStart?.({
+            numJourneys: this.#journeys.length,
+            networkConditions: options.networkConditions,
+        });
+        /**
+         * Set up the directory for caching screenshots
+         */
+        await (0, promises_1.mkdir)(helpers_1.CACHE_PATH, { recursive: true });
+    }
+    async _run(options) {
+        this.config = options;
+        let result = {};
         if (this.#active) {
             return result;
         }
         this.#active = true;
-        (0, logger_1.log)(`Runner: run ${this.journeys.length} journeys`);
-        this.init(options);
-        await this.runBeforeAllHook({
-            env: options.environment,
-            params: options.params,
-        }).catch(e => (this.hookError = e));
+        (0, logger_1.log)(`Runner: run ${this.#journeys.length} journeys`);
+        this.#init(options);
+        const hookArgs = this.buildHookArgs();
+        await this.#runBeforeAllHook(hookArgs).catch(e => (this.#hookError = e));
         const { dryRun, grepOpts } = options;
-        /**
-         * Skip other journeys when using `.only`
-         */
-        const onlyJournerys = this.journeys.filter(j => j.only);
+        // collect all journeys with `.only` annotation and skip the rest
+        const onlyJournerys = this.#journeys.filter(j => j.only);
         if (onlyJournerys.length > 0) {
-            this.journeys = onlyJournerys;
+            this.#journeys = onlyJournerys;
         }
-        for (const journey of this.journeys) {
-            /**
-             * Used by heartbeat to gather all registered journeys
-             */
-            if (dryRun) {
-                this.#reporter.onJourneyRegister?.(journey);
-                continue;
-            }
-            if (!journey.isMatch(grepOpts?.match, grepOpts?.tags) || journey.skip) {
-                continue;
-            }
-            const journeyResult = this.hookError
-                ? await this.runFakeJourney(journey, options)
-                : await this.runJourney(journey, options);
+        else {
+            // filter journeys based on tags and skip annotations
+            this.#journeys = this.#journeys.filter(j => j._isMatch(grepOpts?.match, grepOpts?.tags) && !j.skip);
+        }
+        // Used by heartbeat to gather all registered journeys
+        if (dryRun) {
+            this.#journeys.forEach(journey => this.#reporter.onJourneyRegister?.(journey));
+        }
+        else if (this.#journeys.length > 0) {
+            result = await this._runJourneys(options);
+        }
+        await this.#runAfterAllHook(hookArgs).catch(async () => await this._reset());
+        await this._reset();
+        return result;
+    }
+    async _runJourneys(options) {
+        const result = {};
+        const browserStart = (0, helpers_1.monotonicTimeInSeconds)();
+        await gatherer_1.Gatherer.launchBrowser(options);
+        this.#browserDelay = (0, helpers_1.monotonicTimeInSeconds)() - browserStart;
+        for (const journey of this.#journeys) {
+            const journeyResult = this.#hookError
+                ? await this.#runFakeJourney(journey, options)
+                : await this._runJourney(journey, options);
             result[journey.name] = journeyResult;
         }
         await gatherer_1.Gatherer.stop();
-        await this.runAfterAllHook({
-            env: options.environment,
-            params: options.params,
-        });
-        await this.reset();
         return result;
     }
-    async reset() {
+    async _reset() {
         this.#currentJourney = null;
-        this.journeys = [];
+        this.#journeys = [];
         this.#active = false;
         /**
          * Clear all cache data stored for post processing by