Gomon is a lightweight, self-hosted monitoring solution for Go applications. It provides essential metrics collection and exposure through HTTP endpoints, with built-in Prometheus compatibility and pprof profiling.
- 🚀 Lightweight and embedded monitoring
- 📊 HTTP metrics tracking (latency, errors, requests)
- 🔍 Prometheus metrics endpoint
- 🛠 Built-in pprof profiling
- 🔒 Zero external dependencies
- 🌐 RESTful API for metrics
- ⚡ Minimal overhead
go get github.com/yourusername/gomonpackage main
import (
"net/http"
"github.com/yourusername/gomon/internal/core"
)
func main() {
// Wrap your handlers with Gomon tracking
http.HandleFunc("/api", core.TrackHandler("api", yourHandler))
http.ListenAndServe(":8080", nil)
}
func yourHandler(w http.ResponseWriter, r *http.Request) {
// Your handler logic
}Gomon can be configured using environment variables:
# Server configuration
GOMON_SERVER_PORT=8080 # Main server port
GOMON_PROFILE_PORT=6060 # Profiler port/health- Health check endpoint/stats- JSON metrics endpoint/metrics- Prometheus-compatible metrics/debug/pprof- Go profiling endpoints (on profile port)
{
"request_count": 150,
"avg_latency": 45.23,
"error_count": 3,
"last_request_time": "2024-03-15T14:30:00Z",
"goroutines": 8,
"memory_usage": 1024
}func main() {
// Create a new handler with tracking
handler := http.HandlerFunc(yourHandler)
trackedHandler := core.TrackHandler("custom-endpoint", handler)
http.Handle("/custom", trackedHandler)
}stats := core.GetStats()
fmt.Printf("Total Requests: %d\n", stats["request_count"])- Go 1.22 or higher
- Make (optional, for using Makefile commands)
# Clone the repository
git clone https://github.com/yourusername/gomon.git
cd gomon
# Install development dependencies
make dev-deps
# Run tests
make test
# Build the binary
make buildmake build- Build the binarymake test- Run testsmake run- Run the servermake lint- Run lintersmake clean- Clean build artifactsmake test-endpoints- Test HTTP endpoints
Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
- Fork the repository
- Create your feature branch (
git checkout -b feature/AmazingFeature) - Commit your changes (
git commit -m 'Add some AmazingFeature') - Push to the branch (
git push origin feature/AmazingFeature) - Open a Pull Request
- Add Gomon as a dependency
go get github.com/yourusername/gomon- Basic Integration Example
package main
import (
"net/http"
"github.com/yourusername/gomon/internal/core"
gomonapi "github.com/yourusername/gomon/internal/api"
)
func main() {
// Start Gomon monitoring server on a different port
go gomonapi.StartServer("8081")
// Your application routes with Gomon middleware
http.HandleFunc("/api/users", core.TrackHandler("users", usersHandler))
http.HandleFunc("/api/products", core.TrackHandler("products", productsHandler))
// Start your application
http.ListenAndServe(":8080", nil)
}
func usersHandler(w http.ResponseWriter, r *http.Request) {
// Your handler logic
}- Advanced Integration with Custom Configuration
package main
import (
"github.com/yourusername/gomon/internal/config"
"github.com/yourusername/gomon/internal/core"
gomonapi "github.com/yourusername/gomon/internal/api"
)
func main() {
// Custom configuration
conf := &config.Config{
ServerPort: "8081",
ProfilePort: "6061",
}
// Start profiler
core.StartProfiler(conf.ProfilePort)
// Start Gomon server
go gomonapi.StartServer(conf.ServerPort)
// Your application code...
}Once integrated, Gomon provides these endpoints on the monitoring port:
http://localhost:8081/health- Health checkhttp://localhost:8081/stats- JSON metricshttp://localhost:8081/metrics- Prometheus format metricshttp://localhost:6061/debug/pprof- Go profiling data
Configure Gomon using these environment variables:
# Monitoring server port
export GOMON_SERVER_PORT=8081
# Profiler port
export GOMON_PROFILE_PORT=6061- Basic Request Tracking
func main() {
http.HandleFunc("/api", core.TrackHandler("api", func(w http.ResponseWriter, r *http.Request) {
// Your handler code
}))
}- Group Multiple Endpoints
func main() {
// Track all API endpoints
apiHandler := http.NewServeMux()
apiHandler.HandleFunc("/users", usersHandler)
apiHandler.HandleFunc("/products", productsHandler)
http.Handle("/api/", core.TrackHandler("api", apiHandler.ServeHTTP))
}- Track with Error Handling
func main() {
http.HandleFunc("/api", core.TrackHandler("api", func(w http.ResponseWriter, r *http.Request) {
if err := processRequest(r); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
}))
}func checkMetrics() {
stats := core.GetStats()
requestCount := stats["request_count"].(int64)
errorRate := float64(stats["error_count"].(int64)) / float64(requestCount)
avgLatency := stats["avg_latency"].(float64)
if errorRate > 0.1 { // 10% error rate
alertHighErrorRate(errorRate)
}
}- Separate Ports: Run Gomon monitoring on a different port than your main application
- Meaningful Names: Use descriptive names in
TrackHandlerfor better metrics - Security: Consider restricting access to monitoring endpoints in production
- Resource Management: Monitor the monitoring! Keep an eye on Gomon's own resource usage
Common issues and solutions:
- Port Conflicts
# If ports are already in use, change them:
export GOMON_SERVER_PORT=8082
export GOMON_PROFILE_PORT=6062-
High Memory Usage
- Consider sampling fewer metrics
- Adjust profiling frequency
-
Missing Metrics
- Ensure handlers are wrapped with
TrackHandler - Check correct port configuration
- Ensure handlers are wrapped with