otelchi

After running the multi-services example, you can visualize the collected observability data using the following interfaces:

• Distributed Tracing: Access the Jaeger UI at http://localhost:16686 to view traces across the front-svc and back-svc services.
• Metrics: Access the Prometheus UI at http://localhost:9090 to query and visualize metrics collected from both services.

The Multi Services Example demonstrates instrumenting multiple services (front-svc and back-svc) to show how distributed tracing and metrics flow through a system.

To run the full environment, including the services, Jaeger (for tracing), and Prometheus (for metrics), ensure you have Docker and Docker Compose installed, then execute the following command:

make run

Once the services are running, you will see logs indicating that the services are listening on their respective ports (e.g., :8090 for front-svc and :8091 for back-svc).

This example demonstrates an HTTP server using go-chi/chi with instrumentation. The server includes a /users/{id:[0-9]+} endpoint and outputs span information to stdout.

To run the example, use Docker Compose to start both the mux-server (the instrumented server) and the mux-client (which triggers a single request).

docker compose up --detach mux-server mux-client

To use otelchi for OpenTelemetry instrumentation with the go-chi/chi router, install the package using go get.

$ go get github.com/riandyrn/otelchi

After running the services, you can view the generated spans from the mux-server by checking its logs in Docker Compose.

docker compose logs mux-server

To stop the mux-server and mux-client services and clean up the environment, use the following command:

docker compose down

The Middleware function accepts variadic Option arguments to customize tracing behavior. While the specific option functions are not defined in this file, they are applied to a config struct during initialization. Common customization areas include:

• Providing a custom TracerProvider.
• Configuring custom propagators for context extraction.
• Setting a custom traceIDResponseHeaderKey to include the Trace ID in response headers.
• Defining a publicEndpointFn to treat certain requests as new root spans (useful for edge gateways).
• Providing chiRoutes to allow the middleware to resolve route patterns earlier in the request lifecycle.

You can configure the middleware to automatically inject the current Trace ID and sampling status into the HTTP response headers. This is useful for client-side debugging or correlating client logs with server traces.

Note: The exact option name is not explicitly shown in this file, but the logic is driven by the traceIDResponseHeaderKey and traceIDResponseHeaderKey configuration fields within the middleware.

The metric package provides middleware that implements OpenTelemetry semantic-convention compliant HTTP server metrics.

Supported metrics:

• http.server.request.duration
• http.server.active_requests
• http.server.request.body.size
• http.server.response.body.size

Note: Legacy metric middleware for request_duration_millis, requests_inflight, and response_size_bytes is available but deprecated.

By default, otelchi may name spans at the end of execution. You can influence span naming using these options:

• WithChiRoutes(routes chi.Routes): Provides the chi routes to the middleware. This allows the middleware to use the route pattern (e.g., /users/{id}) as the span name during span creation, rather than the raw URL. This is useful if you want to allow underlying handlers to override the span name.
• WithRequestMethodInSpanName(isActive bool): Adds the HTTP method (e.g., GET, POST) to the span name. This is recommended for vendors like Elastic or New Relic that may not automatically include the method in the span name.

// Use chi routes for pattern-based span names
opts := otelchi.WithChiRoutes(r.RouteContext(r.Context()))

// Include HTTP method in span names
opts := otelchi.WithRequestMethodInSpanName(true)

The Middleware function creates an OpenTelemetry tracing middleware for go-chi routers. It starts a new span for incoming requests, extracts tracing context from headers using the configured propagator, and automatically records HTTP attributes like status codes and route patterns.

To use it, call otelchi.Middleware(serverName, opts...) where serverName is a string describing your server. You can pass optional configuration via functional options.

By default, it uses the global OpenTelemetry TextMapPropagator and TracerProvider if none are provided via options.

import (
	"github.com/go-chi/chi/v5"
	"github.com/riandyrn/otelchi"
)

r := chi.NewRouter()
r.Use(otelchi.Middleware("my-server-name"))

r.Get("/hello", func(w http.ResponseWriter, r *http.Request) {
	w.Write([]byte("world"))
})