Forem: Command Line Pirate 🏴‍☠️

3 Bash One-Liners to Analyze Production Issues 10X Faster

Command Line Pirate 🏴‍☠️ — Thu, 12 Dec 2024 00:48:33 +0000

Life would be so much simpler if apps stopped failing in production, right?

Since that's probably not happening in this life, you need to get better at analyzing issues and make best use of tooling.

Today, I’m sharing 3 bash scripts that will help you debug production issues:

#1: Analyze CPU Usage

During development, have you ever run into following issues?

High CPU usage
Slow response times
Application Crashes

If you’ve experience running a production application I guess you answered yes.

And the first place to look in such scenarios is your server CPU usage.

You can use following bash script to monitor CPU usage over time and identify the processes eating resources and possibly causing the issue:

top -b -n 1 | grep 'Cpu(s)' | awk '{print $2 + $4}' | while read cpu; do echo "$cpu"; sleep 1; done | awk '{print "CPU Usage: " $1 "%"}'

#2: Analyze Network Usage

To identify and fix network related performance bottlenecks—like slow load times, high latency, etc —analyze network traffic for requests, response times and errors. Fixing these will improve your website speed and user experience.

Here’s quick script that provides a basic analysis of HTTP status codes, which can help identify common network errors and their frequency.

curl -s https://example.com | grep -o 'HTTP/[0-9.]* [0-9]*' | awk '{print $2}' | sort -n | uniq -c | sort -nr

#3: Analyze Memory Usage

Given the log & data tsunami that developers are experiencing today, it's critical to separate the signal from the noise. Without the ability to analyze server memory, it's impossible to debug memory leaks, high memory consumption and application crashes due to them.

Use following command to monitor memory usage over time and identify the processes consuming significant memory. You can also use it to optimize memory usage and improve application stability and performance.

free -m | awk '/Mem:/ {print $3}' | while read mem; do echo "$mem"; sleep 1; done | awk '{print "Memory Usage: " $1 "MB"}'

And that’s it.

Hope you’d find these commands useful while analyze production issues.

Also, comment below which production issue you find hardest to debug?

3 Ready-to-Copy Bash Scripts to Visualize Python Code

Command Line Pirate 🏴‍☠️ — Wed, 11 Dec 2024 01:23:18 +0000

Understanding code with a visual is 10x easier than from just reading it.

Want to know how to create one quickly?

Here are my 3 best bash scripts I use to visualize python code:

Visualize Code Structure

You never know when you're going to run into your next overly complex code, and without a tool it's hard to spot code complexity. This can result in poor readability and risk of bugs as the project scales .

But there's an easy way to do this with code structure graph. With pyan3, you can quickly create a dependency of graph of your code and then use dot to render it as PNG image.

pyan3 yourfile.py --dot > code-structure.dot && dot -Tpng code-structure.dot -o code-structure.png

Visualize Control Flow

Sometimes, in python codebase you'll find sections of code that are never executed due to conditional logic, loops or return statements. This redundant or forgotten code can lead to messy codebase, poor maintainability and potential bugs.

With Control Flow Graphs you can easily identify such unreachable and dead code paths. Let pycfg take care of the heavy lifting for you, by outputting control flow graph of your Python code as SVG file.

pycfg yourfile.py > controlflow.svg

Visualize Module Dependencies

While working with python modules, one issue that comes up is of circular dependency — where two or more modules reference each other in a loop. This generally leads to import errors and performance issues.

Fortunately, with a module dependency graph, you can easily spot these problematic relationships. And with snakefood tool, you can easily create one.

sfood yourfile.py | dot -Tpng -o module-dependencies.png

And that’s it.

Hope you’d find these commands useful while creating visuals for Python code.

Also, comment below which code visual you find the most helpful?

4 Commands to Debug “Silent Errors” in JavaScript

Command Line Pirate 🏴‍☠️ — Mon, 09 Dec 2024 17:09:16 +0000

By silent errors here I mean an issue that doesn't produces any visible indication.

Some common examples:

Missing Catch Blocks
Long-Running Promises
Shared State Race Conditions
Erroneous Event Listeners

Let’s understand each error in detail and command to debug them:

#1: Debugging Missing Catch Blocks

These errors occur when you miss attaching .catch() handler to your promise. As a result when the promise is rejected, error isn’t surfaced.

You can debug this error by running your code with unhandled-rejections argument. It forces node to terminate the process on unhandled promise rejections, making the error explicit.

node --unhandled-rejections=strict script.js

#2: Debugging Long-Running Promises

Have you come across a Node.js code that:

Never completes
Consumes excessive memory over time

If yes, then it’s most likely caused by unresolved promise or infinite loop somewhere.

You can validate the issue by limiting the execution time of the script like done below:

timeout 10s node script.js || echo "Warning: Unresolved promise or infinite loop detected"

#3: Debugging Shared State Race Conditions

Shared State Race Conditions occur when multiple callbacks access shared state simultaneously.

Due to the race condition, the program results in unpredictable outcome causing data inconsistencies without visible symptoms during testing.

But fortunately node actually provides a trace-async-hooks option to identify such execution patterns.

node --trace-async-hooks script.js 2>&1 | grep "asyncId"

#4: Debugging Erroneous Event Listeners

Finally let’s talk about errors within event listeners.

These are caused by unhandled promise rejections within event listener callback. This leads to error never getting propagated to the main execution context.

You can identify these errors by redirecting all node event logs to a grep filter to capture errors emitted during event handling

node -r events script.js 2>&1 | grep "Error"

And That’s it.

Hope you’d find these commands useful while debugging silent errors in JavaScript code.

Also, comment below which silent error annoys you the most?

3 Bash Commands to Effectively Work With React Components

Command Line Pirate 🏴‍☠️ — Sun, 08 Dec 2024 18:27:12 +0000

Working with React Components can get daunting at times especially with large codebases.

In this post, I’m sharing 3 bash commands that I use to make some of that work easier.

Let’s dive in!

#1: Find Components With Hardcoded Text

For easier debugging you might have harcoded some values in code.

But it’s always a good idea to get rid of them before productionization. As hard coding text makes localization difficult which becomes a barrier in globalizing the app.

You can use the following command to find hardcoded text, so that your app can support multiple languages:

grep -Er "['\"].*['\"]" src/**/*.jsx | grep -v 'i18n' | tee hardcoded_text.log

#2: identify Components Missing a Test File

Another command which i regularly use to debug low test coverage.

It’s to find what all components miss a test.

Use this command to list all react components that are missing a test file:

find src -name '*.jsx' | sed 's/.jsx$/.test.js/' | while read file; do [ ! -f "$file" ] && echo "Missing test: $file"; done

#3: Check Deprecated Lifecycle Methods

If you’re upgrading your React codebase to a new version, first problem you’ll face is of deprecated lifecycle method.

Run the following bash command to proactively identify outdated code and smoother upgrades.

grep -Er '(componentWillMount|componentWillReceiveProps|componentWillUpdate)' src/**/*.jsx

And that’s it.

Hope you’d find these commands useful while working with React components.

Also, comment below which boring coding task are you procrastinating to automate?