This content originally appeared on DEV Community and was authored by Seyed Ahmad
When working with Go, performance is often a key consideration. Whether you’re building a small CLI tool or a large-scale backend service, understanding how your code consumes CPU, memory, and other resources is essential.
That’s where profiling comes in.
In this post, we’ll walk through Go’s built-in profiling tools, how to use them, and how to interpret their results.
🚀 What is Profiling in Go?
Profiling is the process of analyzing the runtime behavior of your Go program to identify:
Where the program spends most of its time
Which functions are the most expensive in terms of CPU or memory
How resources like goroutines and mutexes are being used
This insight helps developers optimize performance and reduce bottlenecks.
🛠️ Go’s Built-in Profiling Tools
Go comes with powerful profiling utilities in the standard library, mainly through the pprof package.
- runtime/pprof
This package allows you to collect different types of profiles programmatically within your application.
package main
import (
"log"
"os"
"runtime/pprof"
)
func main() {
f, err := os.Create("cpu.prof")
if err != nil {
log.Fatal(err)
}
defer f.Close()
if err := pprof.StartCPUProfile(f); err != nil {
log.Fatal(err)
}
defer pprof.StopCPUProfile()
// Example workload
for i := 0; i < 1000000; i++ {
_ = i * i
}
}
This example creates a CPU profile that you can later analyze.
- net/http/pprof
For long-running applications like servers, Go offers HTTP-based profiling with a simple import:
package main
import (
"log"
"net/http"
_ "net/http/pprof"
)
func main() {
log.Println(http.ListenAndServe("localhost:6060", nil))
}
This exposes endpoints like:
/debug/pprof/cpu
/debug/pprof/heap
which can be accessed via a browser or tools like curl.
- Profiling During Tests
Go’s test tool includes built-in flags for profiling:
go test -cpuprofile=cpu.out -memprofile=mem.out ./...
This automatically generates profiling data while your tests run.
📊 Analyzing Profile Data with go tool pprof
Once you have generated profile data (e.g., cpu.prof or mem.out), you can analyze it with:
go tool pprof cpu.prof
Or, for a web-based visualization:
go tool pprof -http=:8080 cpu.prof
The tool provides call graphs, flame graphs, and detailed function cost analysis.
🔍 Types of Profiles in Go
Go supports multiple profiling types:
CPU Profile → Where the program spends CPU time
Heap Profile → Memory allocations & leaks
Goroutine Profile → Active goroutines & their stacks
Block Profile → Points where goroutines block on resources
Mutex Profile → Mutex contention issues
Each profile type gives a different perspective on your program’s behavior.
✅ Conclusion
Profiling in Go is straightforward yet powerful thanks to its built-in tooling. By leveraging runtime/pprof, net/http/pprof, and test flags, you can easily gather runtime data. With go tool pprof, you gain insights into how your application behaves under real workloads.
👉 Whether you’re chasing down a memory leak or optimizing CPU usage, profiling is your best friend.
✨ What about you? Have you used Go’s pprof before, or do you rely on external tools like Prometheus or Jaeger for performance monitoring? Share your experience in the comments!
This content originally appeared on DEV Community and was authored by Seyed Ahmad
Seyed Ahmad | Sciencx (2025-08-26T19:55:26+00:00) Profiling in Go: A Practical Guide to Finding Performance Bottlenecks. Retrieved from https://www.scien.cx/2025/08/26/profiling-in-go-a-practical-guide-to-finding-performance-bottlenecks/
Please log in to upload a file.
There are no updates yet.
Click the Upload button above to add an update.