Getting Puppeteer timeouts often on 'await browser.newpage'

Question

I inherited a script to manage a deploy of Salesforce code to multiple orgs in one go, to ensure all orgs are on the same version. The code is maintained in a Github respository and the final step is the update of the main branch, so the deploy therefore has to be successful for all orgs before it updates the main branch. Currently we have 32 orgs for which the deploys run simultaneously (with more to be added).

The final step after the code has deployed successfully is to check all the Salesforce to Salesforce connections and mappings, since all the orgs update a 'hub' org. It is in this step that I've started getting Puppeteer timeouts. Sometimes it completes, sometimes it fails. It seems to be getting worse in that I have to rerun it 2 or 3 times to get it pass without timing out. I'm not experienced in Node or Puppeteer or scripts like these so don't know how to stop this happening. I've tried increasing the timeout from the default 30000 to 90000 but even then it fails sometimes so that is not a solution, obviously.

Interestingly a few of us have also been having problems lately with Chrome being dreadfully slow and timing out just in the browser (we run on the latest version of Chrome) and I read that Puppeteer uses Chrome. I tried googling but haven't found anything that helps me hence posting this query here.

I would appreciate any help to sort this out because running it multiple times for each deploy is not a viable solution, especially with the length of time it takes to complete.

This is the function from where it sets the timeout.

async function checkDifferencesForConnectionSafely(
  argv: Config,
  browser: Browser,
  connection: Connection,
  changes: SubscribedFieldUpdate[]
  ): Promise<void> {
 const page = await browser.newPage();
 page.setDefaultNavigationTimeout(90000); // added this but it still times out

 try {
   console.log(`Checking ${connection.username} -> ${connection.name}`);
   await checkDifferencesForConnection(argv, page, connection, changes);
   console.log(`Finished ${connection.username} -> ${connection.name}`);
  } catch (e) {
   console.log(`Failed ${connection.username} -> ${connection.name}`, e);
   throw e;
  } finally {
   await page.close();
  }
}

And this is the called function where I believe the timeout happens:

async function checkDifferencesForConnection(
  argv: Config,
  page: Page,
  connection: Connection,
  changes: SubscribedFieldUpdate[]
): Promise<void> {
  await page.goto(connection.url);
  const subscribedObjects = await getSubscribedObjects(page);

  for (const object of subscribedObjects) {
    await gotoObject(page, object);

    const fields = await getSubscribedFields(page);
    let changesMade = false;

    for (const field of fields) {
      field.isStrict = argv.strict;
      if (field.selectedValueNeedsUpdate()) {
        const newValue = field.newValue();
        changes.push({
          connection,
          connectionObject: object,
          connectionField: field,
          newValue
        });

        await selectMapping(page, field, newValue);
        changesMade = true;
      } else if (!field.value) {
        const options = field.options.map((o) => o.name);
        throw new Error(
          `No value for ${connection.name} -> ${object.name} -> ${field.name}, ` +
            `options: ${options.join(", ")}`
        );
      }
    }

    if (!argv.skipPicklists) {
      if (!argv.dryRun && changesMade) {
        await saveSubscribedFields(page);
        await gotoObject(page, object);
        changesMade = false;
      }

      const pickListMappings = await getPicklistMappingLinks(page);
      for (const pickListMapping of pickListMappings) {
        try {
          await pickListMapping.click();
        } catch (e) {
          console.log(
            `Failed ${connection.username} -> ${connection.name} -> ${object.name} -> ${pickListMapping.id}`,
            e
          );
          throw e;
        }
        const picklistValues = await getPicklistValues(page);

        for (const picklistValue of picklistValues) {
          picklistValue.isStrict = argv.strict;
          if (picklistValue.selectedValueNeedsUpdate()) {
            const newValue = picklistValue.newValue();
            changes.push({
              connection,
              connectionObject: object,
              connectionField: picklistValue,
              newValue
            });

            await selectMapping(page, picklistValue, newValue);
            changesMade = true;
          }
        }
        await savePicklistMapping(page);
      }
    }

    if (!argv.dryRun && changesMade) {
      await saveSubscribedFields(page);
    }
  }
}

This is the error thrown (after running 2hrs 40min!)It is close to the end of the process so has completed most of the org checks at this stage. It doesn't always fail in the same place or on the same org checks so the timeout is not related to a specific connection.

The full script is here:

import puppeteer, { Browser, Page } from "puppeteer";
import { flatten } from "lodash";
import yargs from "yargs";
import pAll from "p-all";

import {
  loginAndGetConnections,
  Connection
} from "../page-objects/sf2sf-home.page-object";
import {
  getSubscribedObjects,
  ConnectionObject
} from "../page-objects/sf2sf-connection.page-object";
import {
  SubscribedField,
  SubscribedFieldOption,
  getSubscribedFields,
  gotoObject,
  selectMapping,
  getPicklistValues,
  save as saveSubscribedFields,
  getPicklistMappingLinks,
  savePicklistMapping
} from "../page-objects/sf2sf-subscribed-fields.page-object";
import { SClusterConfig } from "../s-cluster-config";

class Config {
  configFile: string;
  clusterConfigFile: string;
  dryRun: boolean;
  strict: boolean;
  concurrency: number;
  skipPicklists: boolean;

  constructor() {
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    const argv: any = yargs
      .scriptName("publish-connections")
      .describe("config-file", "The file configuring the SF2SF sync.")
      .alias("config-file", "c")
      .default("config-file", "./sf2sf.config.json")
      .describe("cluster-config-file", "The file configuring the SF2SF sync.")
      .alias("cluster-config-file", "f")
      .string("cluster-config-file")
      .required("cluster-config-file")
      .describe(
        "dry-run",
        "don't make any changes, just print what you're going to do."
      )
      .boolean("dry-run")
      .default("dry-run", false)
      .describe("strict", "Prevents associations from being unassigned")
      .boolean("strict")
      .default("strict", false)
      .number("concurrency")
      .default("concurrency", 10)
      .describe("skip-picklists", "Skip assigning the picklists")
      .boolean("skip-picklists")
      .default("skip-picklists", false).argv;

    this.configFile = argv["config-file"];
    this.clusterConfigFile = argv["cluster-config-file"];
    this.dryRun = argv["dry-run"];
    this.strict = argv["strict"];
    this.concurrency = argv["concurrency"];
    this.skipPicklists = argv["skip-picklists"];
  }
}

interface SubscribedFieldUpdate {
  connection: Connection;
  connectionObject: ConnectionObject;
  connectionField: SubscribedField;
  newValue?: SubscribedFieldOption;
}

async function checkDifferencesForConnection(
  argv: Config,
  page: Page,
  connection: Connection,
  changes: SubscribedFieldUpdate[]
): Promise<void> {
  await page.goto(connection.url);
  const subscribedObjects = await getSubscribedObjects(page);

  for (const object of subscribedObjects) {
    await gotoObject(page, object);

    const fields = await getSubscribedFields(page);
    let changesMade = false;

    for (const field of fields) {
      field.isStrict = argv.strict;
      if (field.selectedValueNeedsUpdate()) {
        const newValue = field.newValue();
        changes.push({
          connection,
          connectionObject: object,
          connectionField: field,
          newValue
        });

        await selectMapping(page, field, newValue);
        changesMade = true;
      } else if (!field.value) {
        const options = field.options.map((o) => o.name);
        throw new Error(
          `No value for ${connection.name} -> ${object.name} -> ${field.name}, ` +
            `options: ${options.join(", ")}`
        );
      }
    }

    if (!argv.skipPicklists) {
      if (!argv.dryRun && changesMade) {
        await saveSubscribedFields(page);
        await gotoObject(page, object);
        changesMade = false;
      }

      const pickListMappings = await getPicklistMappingLinks(page);
      for (const pickListMapping of pickListMappings) {
        try {
          await pickListMapping.click();
        } catch (e) {
          console.log(
            `Failed ${connection.username} -> ${connection.name} -> ${object.name} -> ${pickListMapping.id}`,
            e
          );
          throw e;
        }
        const picklistValues = await getPicklistValues(page);

        for (const picklistValue of picklistValues) {
          picklistValue.isStrict = argv.strict;
          if (picklistValue.selectedValueNeedsUpdate()) {
            const newValue = picklistValue.newValue();
            changes.push({
              connection,
              connectionObject: object,
              connectionField: picklistValue,
              newValue
            });

            await selectMapping(page, picklistValue, newValue);
            changesMade = true;
          }
        }
        await savePicklistMapping(page);
      }
    }

    if (!argv.dryRun && changesMade) {
      await saveSubscribedFields(page);
    }
  }
}

async function checkDifferencesForConnectionSafely(
  argv: Config,
  browser: Browser,
  connection: Connection,
  changes: SubscribedFieldUpdate[]
): Promise<void> {
  const page = await browser.newPage();
  page.setDefaultNavigationTimeout(90000);

  try {
    console.log(`Checking ${connection.username} -> ${connection.name}`);

    await checkDifferencesForConnection(argv, page, connection, changes);

    console.log(`Finished ${connection.username} -> ${connection.name}`);
  } catch (e) {
    console.log(`Failed ${connection.username} -> ${connection.name}`, e);
    throw e;
  } finally {
    await page.close();
  }
}

(async (): Promise<void> => {
  const argv = new Config();

  const { clusterConfigFile, concurrency } = argv;

  const clusterConfig = await SClusterConfig.fromPath(clusterConfigFile);

  const browser = await puppeteer.launch({});

  const connections = flatten(
    await pAll(
      clusterConfig.usernames.map(
        (username) => (): Promise<Connection[]> =>
          loginAndGetConnections(browser, username)
      ),
      { concurrency }
    )
  ).filter((conn) => conn.isActive);

  const differences: SubscribedFieldUpdate[] = [];

  await pAll(
    connections.map(
      (connection) => (): Promise<void> =>
        checkDifferencesForConnectionSafely(
          argv,
          browser,
          connection,
          differences
        )
    ),
    { concurrency }
  );

  const result = differences.map(
    ({ connection, connectionObject, connectionField, newValue }) => ({
      username: connection.username,
      connection: connection.name,
      object: connectionObject.name,
      field: connectionField.name,
      oldValue: (connectionField.value && connectionField.value.name) || "",
      newValue: (newValue && newValue.name) || ""
    })
  );

  console.log(JSON.stringify(result, null, "  "));

  await browser.close();
})();