Observability with OpenTelemetry

Fri, 10 Apr 2026 10:00:00 +0300

This guide walks through building observability into a service from scratch using OpenTelemetry. By the end you will have traces, metrics, and logs flowing into a collector and visualized in Grafana.

Part 1: Why Observability Matters

Logs tell you what happened. Metrics tell you how much. Traces tell you why. Together they give you the full picture when something breaks at 3 AM.

OpenTelemetry is the industry standard for instrumentation. It is vendor-neutral, has SDKs for every major language, and integrates with every major backend (Jaeger, Prometheus, Datadog, Grafana Cloud).

Part 2: Your First Trace

Install the Go SDK:

go get go.opentelemetry.io/otel
go get go.opentelemetry.io/otel/sdk

Create a tracer provider and wrap your HTTP handler:

func main() {
 tp := initTracerProvider()
 defer tp.Shutdown(context.Background())

 mux := http.NewServeMux()
 mux.HandleFunc("/api/users", usersHandler)

 handler := otelhttp.NewHandler(mux, "server")
 http.ListenAndServe(":8080", handler)
}

Every incoming request now generates a span with method, route, status code, and duration.

Part 3: Adding Custom Spans

Automatic instrumentation covers the edges. For the interesting parts — database queries, cache lookups, business logic — add manual spans:

func getUser(ctx context.Context, id string) (*User, error) {
 ctx, span := tracer.Start(ctx, "getUser")
 defer span.End()

 span.SetAttributes(attribute.String("user.id", id))

 // ...
}

Part 4: Metrics and the Collector

Coming soon — configuring the OTel Collector, Prometheus scraping, and Grafana dashboards.

Go Testing: From Zero to CI

Wed, 08 Apr 2026 09:00:00 +0300

Go has one of the best built-in testing stories of any language. No framework to install, no configuration files, no test runner debates. Just go test ./... and you are done.

This guide covers everything from writing your first test to running a full integration suite in CI.

Part 1: The Basics

Every test file ends in _test.go. Every test function starts with Test and takes a *testing.T:

func TestAdd(t *testing.T) {
 got := Add(2, 3)
 if got != 5 {
 t.Errorf("Add(2, 3) = %d, want 5", got)
 }
}

Run it:

go test ./...

Part 2: Table-Driven Tests

The standard Go pattern for testing multiple cases:

func TestAdd(t *testing.T) {
 tests := []struct {
 name string
 a, b int
 want int
 }{
 {"positive", 2, 3, 5},
 {"zero", 0, 0, 0},
 {"negative", -1, 1, 0},
 }

 for _, tt := range tests {
 t.Run(tt.name, func(t *testing.T) {
 if got := Add(tt.a, tt.b); got != tt.want {
 t.Errorf("Add(%d, %d) = %d, want %d", tt.a, tt.b, got, tt.want)
 }
 })
 }
}

Part 3: Integration Tests with Build Tags

Separate slow integration tests from fast unit tests using build tags:

//go:build integration

package db_test

func TestDatabaseQuery(t *testing.T) {
 // requires a running database
}

Run only unit tests: go test ./... Run everything: go test -tags=integration ./...

Part 4: CI Pipeline

Coming soon — GitHub Actions workflow, test caching, and coverage reporting.

Guides on hxmn.dev