puppeteer : how check if browser is still open and working

Question

im trying to open multiple tabs in a single browser instance, after they're done i close the tabs and then re-opening those tabs every x seconds... but i want to keep the browser itself open so i dont have to login in each tab on every loop

so the browser remains open, tabs open and close

here is my simplified code, pleas ignore syntax erros

var  global_browser = false ;
async function init_puppeteer( settings ) {



    if(global_browser === false )
        global_browser = await puppeteer.launch({headless: false  , args:['--no-sandbox']});

    for(var i = 0  ; i < settings.length ; i++ )
    {
        var setting = settings[i];
        open_tab($setting);
    }
}



 async function open_tab( setting ){
    const page    = await global_browser.newPage();
    // do stuff 
    page.close();   
}

setInterval(function (){
    init_puppeteer(settings)
}, 50000 );

here is the problem, sometimes browser crashes or it get closed for whatever reason but the global_browser remains an object /instance of puppeteer... of curse it wont work when i try open a tab with that instance, and i get something like

(node:5720) UnhandledPromiseRejectionWarning: Error: WebSocket is not open: readyState 3 (CLOSED)

here is my question, how can i check and make sure i have a working/open instance of puppeteer in global_browser ? so i can create a new instance and replace it if the previous one is closed

Answer 1

Use browser.on('disconnected') .

You can use browser.on('disconnected') to listen for when the browser is closed or crashed, or if the browser.disconnect() method was called.

Then, you can automatically relaunch the browser, and continue with your program.

The following class will launch the browser, and automatically relaunch the browser whenever the 'disconnected' event is fired:

class BrowserHandler {
  constructor() {
    const launch_browser = async () => {
      this.browser = false;
      this.browser = await puppeteer.launch();
      this.browser.on('disconnected', launch_browser);
    };
    
    (async () => {
      await launch_browser();
    })();
  }
}

BrowserHandler.browser will return false when disconnected.

Additionally, the following function will give you the ability to force your program to wait for the browser to finish launching before continuing any further:

const wait_for_browser = browser_handler => new Promise((resolve, reject) => {
  const browser_check = setInterval(() => {
    if (browser_handler.browser !== false) {
      clearInterval(browser_check);
      resolve(true);
    }
  }, 100);
});

---

Complete Example:

'use strict';

const puppeteer = require('puppeteer');

/**
 * Class: BrowserHandler
 *     Relaunch Browser when Closed
 *     Return false when Browser is Disconnected
 */

class BrowserHandler {
  constructor() {
    const launch_browser = async () => {
      this.browser = false;
      this.browser = await puppeteer.launch();
      this.browser.on('disconnected', launch_browser);
    };
    
    (async () => {
      await launch_browser();
    })();
  }
}

/**
 * Function: wait_for_browser
 *     Wait for Browser to Finish Launching
 */

const wait_for_browser = browser_handler => new Promise((resolve, reject) => {
  const browser_check = setInterval(() => {
    if (browser_handler.browser !== false) {
      clearInterval(browser_check);
      resolve(true);
    }
  }, 100 );
});

// Main Program

(async () => {
  // Open Browser
  
  const browser_handler = new BrowserHandler;
  
  await wait_for_browser(browser_handler);
  
  // Open New Page
  
  let page = await browser_handler.browser.newPage();
  
  await page.goto('https://www.example.com/');
  
  // Disconnect and Automatically Reconnect Browser
  
  browser_handler.browser.disconnect();
  
  if (browser_handler.browser === false) {
    console.log('The browser has been disconnected.');
    
    await wait_for_browser(browser_handler);
  }
  
  console.log('The browser has been reconnected.');
  
  // Close and Automatically Reopen Browser
  
  await browser_handler.browser.close();
  
  if (browser_handler.browser === false) {
    console.log('The browser has been closed.');
    
    await wait_for_browser(browser_handler);
  }
  
  console.log('The browser has been reopened.');
  
  // Force Close Puppeteer
  
  process.exit();
})();

Result:

The browser has been disconnected.

The browser has been reconnected.

The browser has been closed.

The browser has been reopened.

Answer 2

If you just close all tabs (or browser window) but browser process is still there (but no any window).

disconnected event will not be triggered.

Then you can check whether all tabs are closed by:

        if ((await browser.pages()).length === 0) {
          // no tabs opening, do stuff
        }

Answer 3

You can make a very simple function to know if the browser process was killed.

async function wasBrowserKilled(browser){
  const procInfo = await browser.process();
  return !!procInfo.signalCode; // null if browser is still running
}

We can use this here,

const browserKilled = await wasBrowserKilled(global_browser);
if(global_browser === false || browserKilled)

It will check if the browser was killed, otherwise it will replace it.

This is just one way out of many provided by the API.

This is the code I used to test this out, see how the output changes if I comment out the browser.close() section.

const puppeteer = require('puppeteer');

puppeteer.launch().then(async browser => {
  const page = await browser.newPage();
  // comment out to keep browser open
  await browser.close();
  console.log({browserKilled: await wasBrowserKilled(browser)});
});

async function wasBrowserKilled(browser){
  const procInfo = await browser.process();
  return !!procInfo.signalCode;
}

Log here,

➜  puppeteer-xvfb git:(direct-script) ✗ node temp/interval_tab.js
{ browserKilled: true }
➜  puppeteer-xvfb git:(direct-script) ✗ node temp/interval_tab.js
{ browserKilled: false }
_

This is different than the event. I made this snippet specially to check the process for this specific question where you check and run it if you want.

Note that this will only produce result if the browser is crashed/closed somehow.