If you are like , then many of your hobby projects and portfolio examples are deployed to Heroku. Like , it is an attractive option to host your project because it is free. Unlike Github Pages, you can host a server on , so I use it whenever I need a free place to deploy a full-stack application. me Github Pages Heroku There is, of course, a catch, which is that your free Heroku dyno (virtual machine instance) will take a nap whenever it has gone for thirty minutes or more without receiving any web traffic. A user who tries to load an application with a sleeping dyno will experience a wait time of up to ten seconds, which is a sufficient amount of time for many users to conclude that your app is broken and move on. Especially in instances when you are using Heroku to showcase your work, like a portfolio project, this is a real problem. An easy solution for Nodejs Fortunately, it is really easy to keep your dyno awake with just a few lines of code. I used , because that is the language my back end is written in. For the sake of reuse, I created a small module, though a simple function is all that is required. Nodejs I used Node's function to make an HTTP request to my app at regular intervals of less than thirty minutes, thus keeping the dyno from snoozing. Why not use instead? It automatically repeats and would be slightly more concise, after all. You certainly could, but I have seen some accounts that can be . Though it is admittedly unlikely my use case would run afoul of this type of problem, it also turned out that error handling was easier using setTimeout, as you will see. setTimeout setInterval setInterval problematic I named my little utility function , and used a statement to declare it as the module's default export. I only needed to install one dependency: , though any Node library that makes HTTP requests will work. wakeUpDyno modules.export node-fetch The function has two parameters, - the address of the dyno (a string) – and – the amount of time in minutes that our function will wait between making its HTTP requests (an integer). url interval is called from inside , passing it both an anonymous callback function, and the length of time it is to wait in milliseconds between calls (the time in minutes – interval – multiplied by 60,000 ms/min). setTimeout wakeUpDyno Then, to wake the dyno, I put the HTTP request inside the callback function, and invoked it with the argument. url fetch = ( ); wakeUpDyno = { milliseconds = interval * ;
    setTimeout( {
        fetch(url);
    }, milliseconds);
}; .exports = wakeUpDyno; const require "node-fetch" const ( ) => url, interval const 60000 => () module This will do the trick of rousing a sleepy dyno, but unlike , will only run once. So, I needed to make the function call itself again after finishing its request. setInterval setTimeout fetch It occurred to me that if a fetch call were to fail, then function execution would never make it to my recursive call, and the program would exit with an error. So I decided to nest the request inside a block, followed by a block containing the recursive call. This way, the function will call itself again, whether or not the previous call fails. fetch try...catch ...finally fetch HTTP = ( ); wakeUpDyno = {
    setTimeout( { { 
            HTTP.get(url, () => { .log( )
            });
        } (err) { .log( );
        } {
            wakeUpDyno(url, interval);
        }

    }, interval);
}; .exports = wakeUpDyno; const require "HTTP" const ( ) => url, interval => () try console `Making HTTP request to ...` ${url} catch console `Error fetching ` ${url} finally module At that point, my utility was functional, but I also wanted to add an optional parameter, and also to give the parameter a default value of 25 minutes. callback interval In case of its failure, I nested the invocation of in another block, situated in the original block. I moved the recursive call to down to the more deeply nested second block, so that it would execute regardless of the success of . callback try...catch...finally ...finally wakeDyno ...finally callback So, my final code looks like this: fetch = ( ); wakeUpDyno = { milliseconds = interval * ;
    setTimeout( { { .log( ); fetch(url).then( .log( )); 
        } (err) { .log( );
        } { {
                callback(); } (e) { callback ? .log( , e.message) : ;
            } { wakeUpDyno(url, interval, callback);
            }
            
        }

    }, milliseconds);
}; .exports = wakeUpDyno; const require "node-fetch" const ( ) => url, interval = , callback 25 const 60000 => () try console `setTimeout called.` // HTTP GET request to the dyno's url => () console `Fetching .` ${url} catch // catch fetch errors console `Error fetching : Will try again in minutes...` ${url} ${err.message} ${interval} finally try // execute callback, if passed catch // catch callback error console "Callback failed: " null finally // do it all again return module To use it, I will it in my project, and invoke it when I start up my server, like this: require Express express = ( ); wakeUpDyno = ( ); PORT = ; DYNO_URL = ; app = express(); app.listen(PORT, () => {
    wakeUpDyno(DYNO_URL); }) const require "express" const require "wokeDyno.js" // my module! const 3000 // whatever port you like const "https://howimadeathing.herokuapp.com" // the url of your dyno const // instantiate Express app // will start once server starts And that is it! Once I uploaded it to Heroku, it worked exactly as intended, and my app hasn't slept since! One small caveat to this project: Heroku allows users a limited number of per month, so if you have multiple apps running this utility, you may run out! For that reason, in a future iteration of this module, I intend to allow scheduling so dyno hours may be rationed more effectively. free dyno hours Please reach out to me with any feedback or corrections. You can access the Github repository for this project, here .

Fetch

Heroku

see more of my work

Read My Stories

Too Long; Didn't Read

Make resilience your competitive advantage

Prevent Your Free Heroku Dyno from Sleeping

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

How To Connect Heroku Server with Slack

Why Being Likable At Work Matters

Windows Sticky Keys Exploit: The War Veteran That Never Dies

Is ‘bias for action’ making product managers lazier?

Zero People Charged With Online Pirating, Swedish Prosecutor's Office Reports

How To Connect Heroku Server with Slack

Why Being Likable At Work Matters

Windows Sticky Keys Exploit: The War Veteran That Never Dies

Is ‘bias for action’ making product managers lazier?

Zero People Charged With Online Pirating, Swedish Prosecutor's Office Reports

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps