In modern software development, observability has become a cornerstone for ensuring application performance, stability, and scalability. Metrics, as a key building block of observability, provide quantitative insights into system behavior, enabling proactive monitoring and optimization. GoFr, an opinionated Go framework, simplifies the process of publishing and managing metrics while adhering to Prometheus standards.

What Are Metrics?

Metrics are quantitative data points that measure the performance and health of a system. Examples include request latency, CPU utilization, memory usage, error rates, and throughput. These metrics allow developers to:

  • Monitor system health at a high level.
  • Identify trends and patterns in behavior.
  • Quickly detect and resolve potential issues.
  • Optimize application performance proactively.

GoFr supports four primary types of metrics:

  1. Counters: Track monotonically increasing values (e.g., successful transactions).
  2. UpDownCounters: Measure values that can increase or decrease (e.g., inventory levels).
  3. Histograms: Analyze distributions of values (e.g., API response times).
  4. Gauges: Record instantaneous values (e.g., memory usage).

Publishing Metrics in GoFr

GoFr provides built-in support for publishing default metrics and creating custom ones tailored to specific use cases. Below is a guide to implementing these metrics in your GoFr application.

1. Counter Metrics

Counters are used to track events that increase over time, such as successful transactions.

package main

import "gofr.dev/pkg/gofr"

func main() {
    app := gofr.New()

    // Define a counter metric
    app.Metrics().NewCounter("transaction_success", "Tracks successful transactions")

    app.POST("/transaction", func(ctx *gofr.Context) (any, error) {
        ctx.Metrics().IncrementCounter(ctx, "transaction_success")
        return "Transaction Successful", nil
    })

    app.Run()
}

2. UpDown Counter Metrics

UpDownCounters are ideal for tracking values that fluctuate, such as daily credit sales.

package main

import "gofr.dev/pkg/gofr"

func main() {
    app := gofr.New()

    // Define an UpDownCounter metric
    app.Metrics().NewUpDownCounter("total_credit_day_sale", "Tracks daily credit sales")

    app.POST("/sale", func(ctx *gofr.Context) (any, error) {
        ctx.Metrics().DeltaUpDownCounter(ctx, "total_credit_day_sale", 1000)
        return "Sale Completed", nil
    })

    app.Run()
}

3. Histogram Metrics

Histograms help analyze distributions by categorizing values into buckets.

package main

import (
    "gofr.dev/pkg/gofr"
    "time"
)

func main() {
    app := gofr.New()

    // Define a histogram metric
    app.Metrics().NewHistogram("transaction_time", "Tracks transaction times", 5, 10, 15, 20)

    app.POST("/transaction", func(ctx *gofr.Context) (any, error) {
        startTime := time.Now()

        // Simulate transaction logic
        elapsedTime := time.Since(startTime).Milliseconds()
        ctx.Metrics().RecordHistogram(ctx, "transaction_time", float64(elapsedTime))

        return "Transaction Completed", nil
    })

    app.Run()
}

4. Gauge Metrics

Gauges are used for recording instantaneous values like stock levels.

package main

import "gofr.dev/pkg/gofr"

func main() {
    app := gofr.New()

    // Define a gauge metric
    app.Metrics().NewGauge("product_stock", "Tracks product stock levels")

    app.POST("/sale", func(ctx *gofr.Context) (any, error) {
        ctx.Metrics().SetGauge("product_stock", 10)
        return "Sale Completed", nil
    })

    app.Run()
}

Adding Labels to Metrics

GoFr enables the use of labels for categorizing metrics further. Labels are key-value pairs that provide additional context about the data being tracked. For example:

ctx.Metrics().IncrementCounter(ctx, "http_requests",
    "status", "200",
    "endpoint", "/api/v1/users")

Labels allow you to create distinct time series for different combinations of label values, enabling granular analysis in tools like Grafana.

Best Practices for Metric Implementation

  1. Cardinality Management Avoid excessive label combinations to prevent performance degradation: 
ctx.Metrics().IncrementCounter(ctx, "login_attempts", "source", "mobile")

  1. Meaningful Naming Conventions

    Use descriptive names for metrics:

    • http_requests_total
    • database_errors
    • cache_hit_ratio

  2. Optimized Histogram Buckets

    Configure histogram buckets based on expected data ranges:

app.Metrics().NewHistogram("api_latency", "ms", 50, 100, 250)
  1. Documentation Include clear descriptions during metric registration: 
app.Metrics().NewCounter("payment_processed", "Tracks successful payments")

Benefits of Using Metrics in GoFr

By integrating metrics into your GoFr application:

  • You gain actionable insights into system performance.
  • Troubleshooting becomes faster and more efficient.
  • Deployment processes are streamlined through proactive monitoring.
  • Application stability improves due to early detection of anomalies.

Conclusion

Metrics are indispensable for building observable systems that perform optimally under dynamic conditions. With GoFr's robust support for counters, histograms, gauges, and labeled metrics in Prometheus format, developers can easily implement observability best practices while maintaining scalability and efficiency.

Call to Action:

Try GoFr: GitHub
Join Developers Community: Discord
Don't forget to check out GoFr and support it by ⭐️-ing the Repo