This content originally appeared on Level Up Coding - Medium and was authored by Lucas Pereyra
Is your App flooded with console.log statements? Have you ever wondered if that may somehow affect your App?
We’ve all been guilty of overusing console.log statements to get immediate feedback on our code. Whether it's for debugging, printing information to make sense of how something works, or just keeping an eye on real-time system status, console.log has become a go-to tool. Many of us have filled our codebases with dozens, if not hundreds, of these statements, hoping to later filter them through a log processing tool when we need to check in on a program, process, or function. But have you ever stopped to think about how console.log might be impacting your app's performance?
A Benchmark
Let’s start with a simple example to highlight the performance pitfalls of using console.log statements:
Nothing too complicated, right? We’re just summing up the first 10 million numbers using a for loop. Now, let’s measure how long it takes to complete:
Result: 49999995000000
Execution time: 13 ms
Pretty straightforward so far. But what if we decide to print the progress in real-time during each iteration?
Adding 0 to sum
...
Adding 9999999 to sum
Result: 49999995000000
Execution time: 26779 ms
Whoa! Now it takes 26 seconds to complete. That’s a huge spike in execution time, with performance degrading by 2000%.
Let’s say we don’t need to print every single iteration and instead opt to log the progress at regular intervals:
Adding 0 to sum
...
Adding 9999900 to sum
Result: 49999995000000
Execution time: 314 ms
While this is definitely an improvement, we’re still far from the performance of the non-printing version. So, what’s causing console.log to slow things down this much?
Slow Input/Output
The console.log statement is an Input/Output (I/O) operation. I/O tasks generally involve interacting with slow devices (in this case, the display) by calling an OS API to execute a command. I/O devices are much slower at processing tasks compared to CPUs, so I/O operations are often handled asynchronously to prevent the CPU from idling while waiting for the task to complete.
However, the console.log directive is a blocking operation. In Node.js, for instance, we apply asynchronous programming principles to handle file operations efficiently, but we don’t follow the same approach when printing output to the console.
On top of blocking the CPU, console.log also performs a serialization process—converting everything it receives into a format that can be printed. This extra step adds to the overhead, further slowing down the execution of your program.
Async Loggers
Asynchronous loggers provide an elegant solution to the performance issue by buffering output into memory and periodically dumping it. This approach eliminates the need for constantly interrupting the CPU to handle I/O operations. Instead, the async logger buffers your logs, automatically flushing them to the terminal or a file once the buffer is full.
Let’s take a look at how this works using the pino logger:
...
{"level":30,"time":1728128033485,"msg":"Adding 38 to sum"}
Result: 49999995000000
Execution time: 7555 ms
{"level":30,"time":1728128033486,"msg":"Adding 39 to sum"}
...
Here we see the logs printed in the Pino logging format, which includes JSON serialization and the log level type. When running this, you’ll notice your results statement will be printed somewhere in the CLI surrounded by the progress prints. This is because the logger works asynchronously, and by the time the function finished running, it may still be printing.
With async loggers, you can set the buffer limit (in bytes), and it will handle the periodic flushing of the content to the desired output, whether that’s the console or a file.
I hope this article helped shed some light on how excessive logging can negatively impact your application’s performance. The severity of this impact depends on the logging techniques and tools you use. While I used JavaScript’s console.log as an example, this issue is relevant across various programming languages.
If you’ve made it this far, congrats! You’re now a bit more knowledgeable about performance optimization. If you enjoyed this article, feel free to leave a clap and subscribe for more content like this. Thanks for reading, and happy coding!
I’m Lucas, a seasoned backend engineer with a passion for designing and building software systems. I write about backend development, from best practices to the latest technologies. Let’s connect on LinkedIn to discuss more!
This is How console.log Degrades Your App Performance was originally published in Level Up Coding on Medium, where people are continuing the conversation by highlighting and responding to this story.
This content originally appeared on Level Up Coding - Medium and was authored by Lucas Pereyra
Lucas Pereyra | Sciencx (2024-10-06T20:55:24+00:00) This is How console.log Degrades Your App Performance. Retrieved from https://www.scien.cx/2024/10/06/this-is-how-console-log-degrades-your-app-performance/
Please log in to upload a file.
There are no updates yet.
Click the Upload button above to add an update.