OpenTelemetry is a set of APIs, libraries, agents, and instrumentation to provide observability for applications. Adding tracing to a Go application with OpenTelemetry is relatively straightforward. Below is a step-by-step example of how to set it up.
package main
import (
"context"
"log"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/sdk/resource"
"go.opentelemetry.io/otel/trace"
"go.opentelemetry.io/otel/sdk/tracesdk"
tracepropagation "go.opentelemetry.io/otel/propagation"
)
func main() {
// Initialize OpenTelemetry
tracerProvider := tracesdk.NewTracerProvider(
tracesdk.WithResource(resource.NewWithAttributes()),
)
otel.SetTracerProvider(tracerProvider)
tracer := otel.Tracer("example.com/hello")
ctx, span := tracer.Start(context.Background(), "main")
defer span.End()
// Your application logic here
exampleFunction(ctx)
}
func exampleFunction(ctx context.Context) {
_, span := otel.Tracer("example.com/hello").Start(ctx, "exampleFunction")
defer span.End()
// Simulate some work
log.Println("Doing some work in exampleFunction...")
}
How do I avoid rehashing overhead with std::set in multithreaded code?
How do I find elements with custom comparators with std::set for embedded targets?
How do I erase elements while iterating with std::set for embedded targets?
How do I provide stable iteration order with std::unordered_map for large datasets?
How do I reserve capacity ahead of time with std::unordered_map for large datasets?
How do I erase elements while iterating with std::unordered_map in multithreaded code?
How do I provide stable iteration order with std::map for embedded targets?
How do I provide stable iteration order with std::map in multithreaded code?
How do I avoid rehashing overhead with std::map in performance-sensitive code?
How do I merge two containers efficiently with std::map for embedded targets?