The only tool you need to know what is happening and how to fix it.
Go alertingexception-trackerissue-trackinglogsmetricsmonitoringobservability-platformopen-telemetryotelsession-replaytelemetrytraces
package main
import (
"context"
"fmt"
"log/slog"
"os"
"time"
"go.opentelemetry.io/contrib/bridges/otelslog"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp"
"go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp"
"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
"go.opentelemetry.io/otel/log/global"
"go.opentelemetry.io/otel/propagation"
sdklog "go.opentelemetry.io/otel/sdk/log"
sdkmetric "go.opentelemetry.io/otel/sdk/metric"
"go.opentelemetry.io/otel/sdk/metric/metricdata"
"go.opentelemetry.io/otel/sdk/resource"
sdktrace "go.opentelemetry.io/otel/sdk/trace"
semconv "go.opentelemetry.io/otel/semconv/v1.26.0"
"go.opentelemetry.io/otel/trace"
)
var (
serviceName string
tracer trace.Tracer
)
func initTelemetry(ctx context.Context) (func(context.Context), error) {
base := os.Getenv("TRACEWAY_URL")
if base == "" {
base = "https://cloud.tracewayapp.com"
}
token := os.Getenv("TRACEWAY_BACKEND_TOKEN")
if token == "" {
return nil, fmt.Errorf("TRACEWAY_BACKEND_TOKEN is required")
}
serviceName = os.Getenv("TRACEWAY_SERVICE_NAME")
if serviceName == "" {
serviceName = "shop-backend"
}
headers := map[string]string{"Authorization": "Bearer " + token}
hostname, _ := os.Hostname()
res, err := resource.New(ctx, resource.WithAttributes(
semconv.ServiceName(serviceName),
semconv.ServiceVersion("0.1.0"),
semconv.HostName(hostname),
))
if err != nil {
return nil, fmt.Errorf("resource: %w", err)
}
traceExporter, err := otlptracehttp.New(ctx,
otlptracehttp.WithEndpointURL(base+"/api/otel/v1/traces"),
otlptracehttp.WithHeaders(headers),
)
if err != nil {
return nil, fmt.Errorf("trace exporter: %w", err)
}
// Delta temporality: Traceway stores Sum data points verbatim, so cumulative
// counters would chart as ever-growing ramps instead of per-interval values.
metricExporter, err := otlpmetrichttp.New(ctx,
otlpmetrichttp.WithEndpointURL(base+"/api/otel/v1/metrics"),
otlpmetrichttp.WithHeaders(headers),
otlpmetrichttp.WithTemporalitySelector(func(sdkmetric.InstrumentKind) metricdata.Temporality {
return metricdata.DeltaTemporality
}),
)
if err != nil {
return nil, fmt.Errorf("metric exporter: %w", err)
}
logExporter, err := otlploghttp.New(ctx,
otlploghttp.WithEndpointURL(base+"/api/otel/v1/logs"),
otlploghttp.WithHeaders(headers),
)
if err != nil {
return nil, fmt.Errorf("log exporter: %w", err)
}
tp := sdktrace.NewTracerProvider(
sdktrace.WithBatcher(traceExporter, sdktrace.WithBatchTimeout(2*time.Second)),
sdktrace.WithResource(res),
)
otel.SetTracerProvider(tp)
tracer = tp.Tracer(serviceName)
mp := sdkmetric.NewMeterProvider(
sdkmetric.WithReader(sdkmetric.NewPeriodicReader(metricExporter, sdkmetric.WithInterval(15*time.Second))),
sdkmetric.WithResource(res),
)
otel.SetMeterProvider(mp)
lp := sdklog.NewLoggerProvider(
sdklog.WithProcessor(sdklog.NewBatchProcessor(logExporter, sdklog.WithExportInterval(2*time.Second))),
sdklog.WithResource(res),
)
global.SetLoggerProvider(lp)
otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(
propagation.TraceContext{}, propagation.Baggage{},
))
slog.SetDefault(slog.New(multiHandler{handlers: []slog.Handler{
slog.NewTextHandler(os.Stdout, nil),
otelslog.NewHandler(serviceName, otelslog.WithLoggerProvider(lp)),
}}))
if err := initMetrics(); err != nil {
return nil, fmt.Errorf("metrics: %w", err)
}
return func(ctx context.Context) {
_ = tp.Shutdown(ctx)
_ = mp.Shutdown(ctx)
_ = lp.Shutdown(ctx)
}, nil
}
type multiHandler struct {
handlers []slog.Handler
}
func (m multiHandler) Enabled(ctx context.Context, level slog.Level) bool {
for _, h := range m.handlers {
if h.Enabled(ctx, level) {
return true
}
}
return false
}
func (m multiHandler) Handle(ctx context.Context, record slog.Record) error {
var firstErr error
for _, h := range m.handlers {
if h.Enabled(ctx, record.Level) {
if err := h.Handle(ctx, record.Clone()); err != nil && firstErr == nil {
firstErr = err
}
}
}
return firstErr
}
func (m multiHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
next := make([]slog.Handler, len(m.handlers))
for i, h := range m.handlers {
next[i] = h.WithAttrs(attrs)
}
return multiHandler{handlers: next}
}
func (m multiHandler) WithGroup(name string) slog.Handler {
next := make([]slog.Handler, len(m.handlers))
for i, h := range m.handlers {
next[i] = h.WithGroup(name)
}
return multiHandler{handlers: next}
}