NeuralBlitz What I do
- Debug application issues effectively
- Use debugging tools and techniques
- Analyze crash dumps and stack traces
- Profile performance bottlenecks
- Debug network issues
- Handle production incidents
- Use logging for debugging
- Write debuggable code
When to use me
When debugging issues or troubleshooting problems.
Debugging Techniques
Scientific Method for Debugging
1. Observe the symptom
- What error message?
- What was the input?
- When does it happen?
2. Form a hypothesis
- What could cause this?
- What's the most likely cause?
3. Test hypothesis
- Can I reproduce it?
- What changes the behavior?
4. Refine hypothesis
- Narrow down the cause
- Test edge cases
5. Fix the bug
- Make minimal change
- Verify the fix
6. Prevent regression
- Add test case
- Document the issue
Python Debugging
import pdb
from typing import Any
# Interactive debugging with pdb
def debug_with_pdb():
"""Start interactive debugger."""
breakpoint() # Python 3.7+
# pdb commands
# n (next) - execute current line
# s (step) - step into function
# c (continue) - run to breakpoint
# l (list) - show source
# p (print) - print variable
# pp (pretty print) - pretty print
# w (where) - show stack trace
# u (up) - go up stack
# d (down) - go down stack
# q (quit) - quit debugger
# Remote debugging with rpdb
import rpdb
def start_remote_debugger(port=4444):
"""Start debugger on specified port."""
rpdb.set_trace(port=port)
# Using icecream for debugging
from icecream import ic
def debug_with_icecream():
"""Print variable values with expressions."""
x = 10
y = 20
z = x + y
ic(x) # ic| x = 10
ic(y) # ic| y = 20
ic(z) # ic| z = 30
ic(x + y) # ic| x + y = 30
# Logging for debugging
import logging
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)
def debug_with_logging(data: dict) -> dict:
"""Debug with structured logging."""
logger.debug("Processing data", extra={
'data_keys': list(data.keys()),
'data_size': len(data),
})
result = {k: v * 2 for k, v in data.items()}
logger.debug("Processed result", extra={
'result': result,
'result_keys': list(result.keys()),
})
return result
# Better debugging with rich
from rich import print as rprint
from rich.pretty import pprint
def debug_with_rich():
"""Pretty print with rich."""
data = {'name': 'test', 'values': [1, 2, 3], 'nested': {'a': 1}}
pprint(data) # Beautiful syntax-highlighted output
JavaScript Debugging
// Console debugging
function debugWithConsole() {
const data = { name: 'test', value: 42 };
// Basic logging
console.log('Data:', data);
// Grouped logs
console.group('Processing');
console.log('Start');
console.log('Processing...');
console.log('Done');
console.groupEnd();
// Table
const users = [
{ name: 'Alice', age: 30 },
{ name: 'Bob', age: 25 },
];
console.table(users);
// Stack trace
console.trace('Stack trace');
// Timing
console.time('operation');
// ... code ...
console.timeEnd('operation');
}
// Chrome DevTools debugging
// 1. Open DevTools (F12)
// 2. Sources panel
// 3. Set breakpoints
// 4. Use debugger statement
function buggyFunction() {
debugger; // Breakpoint
// Step through code
}
// VS Code debugging
// .vscode/launch.json
{
"version": "0.2.0",
"configurations": [
{
"type": "node",
"request": "launch",
"name": "Debug",
"program": "${workspaceFolder}/app.js",
"skipFiles": ["<node_internals>/**"]
}
]
}
Performance Profiling
import cProfile
import pstats
from memory_profiler import profile, memory_usage
import time
def profile_code():
"""Profile CPU usage."""
profiler = cProfile.Profile()
profiler.enable()
# Code to profile
result = [i * 2 for i in range(10000)]
profiler.disable()
# Print stats
stats = pstats.Stats(profiler)
stats.sort_stats('cumulative')
stats.print_stats(20) # Top 20 functions
@profile # Memory profiler decorator
def profile_memory():
"""Profile memory usage."""
data = [i * 2 for i in range(100000)]
time.sleep(0.1)
return data
# Line-by-line profiling
from line_profiler import LineProfiler
def profile_lines():
profiler = LineProfiler()
profiler.add_function(slow_function)
profiler.enable_by_count()
slow_function()
profiler.disable()
profiler.print_stats()
Debugging Production Issues
import sys
import traceback
class ProductionDebugger:
"""Debug issues in production safely."""
def __init__(self, log_file: str = '/var/log/app/debug.log') -> None:
self.log_file = log_file
def setup_error_handling(self) -> None:
"""Setup comprehensive error handling."""
sys.excepthook = self.handle_exception
def handle_exception(self, exc_type, exc_value, exc_traceback) -> None:
"""Log exceptions with full context."""
import os
# Log to file
with open(self.log_file, 'a') as f:
f.write(f"\n{'='*60}\n")
f.write(f"Exception: {exc_type.__name__}\n")
f.write(f"Message: {exc_value}\n")
f.write(f"Traceback:\n")
tb = traceback.format_exception(exc_type, exc_value, exc_traceback)
f.write(''.join(tb))
# Add context
f.write(f"\nProcess ID: {os.getpid()}\n")
f.write(f"Working Directory: {os.getcwd()}\n")
def add_context(self, key: str, value: Any) -> None:
"""Add context to error messages."""
# Store in thread-local or async context
pass
def capture_state(self) -> dict:
"""Capture current application state."""
import gc
import psutil
import os
process = psutil.Process(os.getpid())
return {
'memory_mb': process.memory_info().rss / 1024 / 1024,
'cpu_percent': process.cpu_percent(),
'open_files': len(process.open_files()),
'threads': len(process.threads()),
'gc_stats': gc.get_stats(),
}
# Debug endpoint for live inspection
from flask import Flask, jsonify
app = Flask(__name__)
@app.route('/debug/state')
def debug_state():
"""Expose debug state for inspection."""
debugger = ProductionDebugger()
return jsonify({
'state': debugger.capture_state(),
'config': {
'debug_mode': True, # Only in debug
},
'environment': {
'python_version': sys.version,
},
})
Network Debugging
import requests
from requests.exceptions import RequestException
class NetworkDebugger:
"""Debug network requests."""
def __init__(self, base_url: str) -> None:
self.base_url = base_url
self.session = requests.Session()
def debug_request(
self,
method: str,
url: str,
**kwargs
) -> requests.Response:
"""Debug a network request."""
full_url = f"{self.base_url}{url}"
print(f"\n{'='*60}")
print(f"Request: {method.upper()} {full_url}")
# Log headers
headers = kwargs.get('headers', {})
print(f"Headers: {dict(headers)}")
# Log body
if 'json' in kwargs:
print(f"Body (JSON): {kwargs['json']}")
elif 'data' in kwargs:
print(f"Body: {kwargs['data']}")
try:
response = self.session.request(method, full_url, **kwargs)
print(f"\nResponse: {response.status_code}")
print(f"Headers: {dict(response.headers)}")
# Log truncated response
content = response.text[:1000]
print(f"Content (truncated): {content}")
return response
except RequestException as e:
print(f"Error: {e}")
raise
def check_connectivity(self, timeout: int = 5) -> dict:
"""Check network connectivity."""
import socket
checks = {}
# DNS check
try:
socket.gethostbyname(self.base_url)
checks['dns'] = 'OK'
except socket.gaierror:
checks['dns'] = 'FAILED'
# TCP check
try:
host = self.base_url.split('://')[1].split('/')[0]
port = 443 if 'https' in self.base_url else 80
socket.create_connection((host, port), timeout)
checks['tcp'] = 'OK'
except Exception:
checks['tcp'] = 'FAILED'
return checks
Common Debugging Patterns
# Binary search debugging
def bisect_debug():
"""Find the breaking change with binary search."""
versions = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# Test middle version
mid = len(versions) // 2
print(f"Testing version {versions[mid]}")
# If it works, test later versions
# If it fails, test earlier versions
# Minimal reproduction
def minimal_reproduction():
"""Create minimal code to reproduce bug."""
# Start with what you know:
# - Error message
# - Input that causes it
# Strip away everything not needed
# until you have the smallest test case
# Diff debugging
def diff_debug():
"""Compare working vs broken state."""
import difflib
working = "correct behavior"
broken = "current behavior"
diff = difflib.unified_diff(
working.splitlines(),
broken.splitlines(),
lineterm='',
)
for line in diff:
print(line)
Debugging Tools Reference
Python:
- pdb - Built-in debugger
- ipdb - IPython-based debugger
- rpdb - Remote debugger
- icecream - Better print debugging
- rich - Rich output
- memory_profiler - Memory profiling
- line_profiler - Line-by-line profiling
- cProfile - CPU profiling
- py-spy - Low-overhead sampling profiler
JavaScript:
- Chrome DevTools - Browser debugging
- VS Code debugger - IDE debugging
- Node.js inspector - Node debugging
- ndb - Improved Node debugging
General:
- strace - System call tracing (Linux)
- ltrace - Library call tracing
- dtrace - Dynamic tracing
- wireshark - Network analysis
- mitmproxy - HTTP proxy for debugging