Solving the Node.js console.time is not a function error

What is console.time?

The console.time, or console.time(), function is one of the built-in timing functions in Node.js. You can access it via the console interface like in the browser environment.

As its name suggests, console.time is used to time the duration that has elapsed between two events. Internally, it uses Node's high-resolution timer of the built-in process object:

console.time("foo");

The console.time function takes an optional string label as an argument and returns undefined. If you don't explicitly pass a label, the default label will be set to 'default'.

Internally, Node creates a Map data structure whose key is the string label you pass to console.time and its value is the high-resolution time. When you call console.timeEnd, Node gets the duration that has elapsed between the two points in time.

You will get a warning if you invoke console.time with the same argument more than once:

>console.time("foo");

console.time("foo");

The code above will emit the following warning:

(node:16923) Warning: Label 'foo' already exists for console.time()

The console.time function is always used with console.timeEnd, which, as its name suggests, stops the timer and calculates the duration of time that has elapsed since console.time was called:

console.time("foo");



setTimeout(() => {

  console.timeEnd("foo");

}, 1_000);

console.timeEnd takes the string passed to console.time as its first argument. It logs the string label and the duration of time that has elapsed since console.time was called in appropriate units and human-readable format:

foo: 1.007s

Another function in the console family of functions is the console.timeLog function. It also takes the string label passed to console.time as its first argument and any number of additional arguments. It logs the duration that has elapsed along with the additional arguments.

Unlike console.timeEnd, console.timeLog doesn't end the timer:

console.time("foo");



setTimeout(() => {

  console.timeLog("foo", "Inside setTimeout");

  console.timeEnd("foo");

}, 1_000);

If you run the code above, you will get the output below. The elapsed time may be slightly different for you:

foo: 1.005s Inside setTimeout

foo: 1.009s

Common causes of the console.time is not a function error

There are several possible causes of the console.time is not a function error in JavaScript. We’ll explore some of them in this section.

Node.js version incompatibility

The console.time and console.timeEnd functions have shipped since Node v0.1.104. Therefore, version incompatibility may be the least likely reason for the console.time is not a function error.

Nevertheless, you need to be sure you're using the right Node version, especially with their corresponding console.timeLog function. The console.timeLog function shipped much later with Node v10.7.9.

Accidentally modifying the console interface

In JavaScript, most built-in objects and functions are mutable and extensible by design. Therefore, it is not unusual to accidentally modify them. You can use the Object.getOwnPropertyDescriptor static method to determine whether a given property of a built-in JavaScript object can be re-assigned, deleted, or modified:

const propertyDescriptor = Object.getOwnPropertyDescriptor(console, "time");

console.log(propertyDescriptor);

The Object.getOwnPropertyDescriptor static method takes an object and a property as arguments and returns a property descriptor object. The code above will log the object below on the terminal:

{

  value: [Function: time],

  writable: true,

  enumerable: true,

  configurable: true

}

You will notice that the writable property is set to true. Therefore, it is possible to accidentally reassign or modify the value of the console.time property without JavaScript throwing an error.

Let us now reassign console.time to undefined and later call it to trigger the console.time is not a function error like in the example below:

console.time = undefined;

console.time("foo"); 

After the reassignment, calling console.time throws the error like the one shown below:

/path/to/file/index.js:2

console.time("foo"); 

        ^



TypeError: console.time is not a function

    at Object.<anonymous> (/path/to/file/index.js:2:9)

    at Module._compile (node:internal/modules/cjs/loader:1254:14)

    at Module._extensions..js (node:internal/modules/cjs/loader:1308:10)

    at Module.load (node:internal/modules/cjs/loader:1117:32)

    at Module._load (node:internal/modules/cjs/loader:958:12)

    at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:81:12)

    at node:internal/main/run_main_module:23:47



Node.js v18.15.0

Instead of triggering the above error by reassigning its value, you could also modify the console object by deleting the console.time property so that it is removed entirely:

delete console.time;

console.time('foo');

Such modification of built-in methods and objects could be accidental or by a third-party package.

Automatic Semicolon Insertion (ASI) and Immediately Invoked Function Expression (IIFE)

Some JavaScript statements require semicolons to be syntactically correct. However, you don't need to add them explicitly because JavaScript has the built-in Automatic Semicolon Insertion (ASI) feature that fixes some invalid tokens out of the box.

ASI makes the language easier to learn and use. Therefore, it is not uncommon for programmers to exclusively rely on it instead of explicitly adding semicolons themselves.

However, this can sometimes lead to unexpected behavior and hard-to-debug errors. A typical example is when a function invocation without a semicolon at the end of the line is followed by an Immediately Invoked Function Expression (IIFE) like in the example below:

console.time('foo')



(function() {})()

You will get the console.time(...) is not a function error if you execute the code above:

/path/to/file/index.js:1

console.time("foo")(function () {})();

                   ^



TypeError: console.time(...) is not a function

    at Object.<anonymous> (/path/to/file/index.js:1:20)

    at Module._compile (node:internal/modules/cjs/loader:1254:14)

    at Module._extensions..js (node:internal/modules/cjs/loader:1308:10)

    at Module.load (node:internal/modules/cjs/loader:1117:32)

    at Module._load (node:internal/modules/cjs/loader:958:12)

    at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:81:12)

    at node:internal/main/run_main_module:23:47



Node.js v18.15.0

The above error was thrown because console.time returned undefined and we tried to invoke undefined as a function with function() {} as argument. If you use .

To know where to add breakpoints, it is always helpful to pay close attention to the stack trace. It will always show a detailed trace of the function or method calls that led to the offending line of code.

You can then add breakpoints at various locations and step through the code one line at a time. As an example, let's assume you have the code below in your project:

try {

  console.time = "foo";

  console.time();

} catch (error) {

  console.log(error.stack);

}

The error stack logged to the console as a result of executing the code above will look like so:

TypeError: console.time is not a function

    at Object.<anonymous> (/path/to/file/index.js:3:11)

    at Module._compile (node:internal/modules/cjs/loader:1254:14)

    at Module._extensions..js (node:internal/modules/cjs/loader:1308:10)

    at Module.load (node:internal/modules/cjs/loader:1117:32)

    at Module._load (node:internal/modules/cjs/loader:958:12)

    at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:81:12)

    at node:internal/main/run_main_module:23:47

You will notice the detailed trace of the method and function calls that led to the error. It displays the file path as well as the line and column numbers. You can use that information to add breakpoints and start debugging your code.

Conclusion

Debugging and dealing with errors is inevitable when writing code. In JavaScript, most built-in objects, functions, and methods are mutable by design.

Therefore, it is not uncommon to accidentally mutate built-in objects like the console interface, resulting in hard-to-debug errors. One of these errors is console.time is not a function.

As already explained, one of the possible causes of this error is mutating the console object or reassigning the console.time property to a non-function value. This could be accidentally or intentionally by a third-party package.

On the other hand, this error could be caused by exclusively relying on JavaScript's built-in Automatic Semicolon Insertion feature to insert semicolons for you. As highlighted above, you will get console.time(...) is not a function error if you have console.time and an Immediately Invoked Function Expression in consecutive lines without a semicolon separating them. Therefore, it's a good practice to be explicit and insert semicolons when writing JavaScript code.

200’s only ✔️ Monitor failed and slow network requests in production

Deploying a Node-based web app or website is the easy part. Making sure your Node instance continues to serve resources to your app is where things get tougher. If you’re interested in ensuring requests to the backend or third party services are successful,

.