Files
mtusi2026lab6/app/internal/telemetry/telemetry.go
T

123 lines
4.8 KiB
Go

// Package telemetry exports only an explicit allowlist of technical request data.
package telemetry
import (
"context"
"fmt"
"os"
"strconv"
"time"
"github.com/labstack/echo/v4"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp"
"go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp"
"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
otellog "go.opentelemetry.io/otel/log"
"go.opentelemetry.io/otel/metric"
"go.opentelemetry.io/otel/propagation"
sdklog "go.opentelemetry.io/otel/sdk/log"
sdkmetric "go.opentelemetry.io/otel/sdk/metric"
"go.opentelemetry.io/otel/sdk/resource"
sdktrace "go.opentelemetry.io/otel/sdk/trace"
"go.opentelemetry.io/otel/trace"
)
var requests metric.Int64Counter
var duration metric.Float64Histogram
var logs otellog.Logger
func Init(ctx context.Context) (func(), error) {
if os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT") == "" || os.Getenv("OTEL_SDK_DISABLED") == "true" {
return func() {}, nil
}
host, _ := os.Hostname()
res := resource.NewWithAttributes("", attribute.String("service.name", "messenger-api"), attribute.String("service.version", "lab6-1"), attribute.String("service.instance.id", host), attribute.String("deployment.environment.name", "lab"))
te, err := otlptracehttp.New(ctx)
if err != nil {
return nil, err
}
ratio := 1.0
if raw := os.Getenv("OTEL_TRACES_SAMPLER_ARG"); raw != "" {
var err error
ratio, err = strconv.ParseFloat(raw, 64)
if err != nil || ratio < 0 || ratio > 1 {
return nil, fmt.Errorf("invalid sampler ratio")
}
}
tp := sdktrace.NewTracerProvider(sdktrace.WithSampler(sdktrace.ParentBased(sdktrace.TraceIDRatioBased(ratio))), sdktrace.WithResource(res), sdktrace.WithBatcher(te, sdktrace.WithMaxQueueSize(1024), sdktrace.WithExportTimeout(3*time.Second)))
me, err := otlpmetrichttp.New(ctx)
if err != nil {
return nil, err
}
mp := sdkmetric.NewMeterProvider(sdkmetric.WithResource(res), sdkmetric.WithReader(sdkmetric.NewPeriodicReader(me, sdkmetric.WithInterval(5*time.Second), sdkmetric.WithTimeout(3*time.Second))))
le, err := otlploghttp.New(ctx)
if err != nil {
return nil, err
}
lp := sdklog.NewLoggerProvider(sdklog.WithResource(res), sdklog.WithProcessor(sdklog.NewBatchProcessor(le, sdklog.WithMaxQueueSize(1024), sdklog.WithExportTimeout(3*time.Second))))
logs = lp.Logger("messenger")
otel.SetTracerProvider(tp)
otel.SetMeterProvider(mp)
otel.SetTextMapPropagator(propagation.TraceContext{})
meter := mp.Meter("messenger")
requests, err = meter.Int64Counter("api_requests")
if err != nil {
return nil, err
}
duration, err = meter.Float64Histogram("api_duration", metric.WithUnit("s"), metric.WithExplicitBucketBoundaries(.005, .01, .025, .05, .1, .25, .5, 1, 2.5, 5, 10))
if err != nil {
return nil, err
}
return func() {
c, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
_ = tp.Shutdown(c)
_ = mp.Shutdown(c)
_ = lp.Shutdown(c)
}, nil
}
func Middleware(next echo.HandlerFunc) echo.HandlerFunc {
return func(c echo.Context) error {
if requests == nil {
return next(c)
}
route := c.Path()
if route == "" {
route = "unmatched"
}
ctx := otel.GetTextMapPropagator().Extract(c.Request().Context(), propagation.HeaderCarrier(c.Request().Header))
ctx, span := otel.Tracer("messenger").Start(ctx, c.Request().Method+" "+route, trace.WithSpanKind(trace.SpanKindServer))
defer span.End()
c.SetRequest(c.Request().WithContext(ctx))
c.Response().Header().Set("X-Trace-Id", span.SpanContext().TraceID().String())
start := time.Now()
if err := next(c); err != nil {
c.Error(err)
}
status := c.Response().Status
attrs := []attribute.KeyValue{attribute.String("method", c.Request().Method), attribute.String("route", route), attribute.String("status_class", fmt.Sprintf("%dxx", status/100))}
requests.Add(ctx, 1, metric.WithAttributes(attrs...))
duration.Record(ctx, time.Since(start).Seconds(), metric.WithAttributes(attrs...))
span.SetAttributes(append(attrs, attribute.Int("http.response.status_code", status))...)
if status >= 500 {
span.SetStatus(codes.Error, "server error")
}
sc := span.SpanContext()
c.Response().Header().Set("X-Trace-Id", sc.TraceID().String())
var rec otellog.Record
rec.SetTimestamp(time.Now())
rec.SetBody(otellog.StringValue("http.request"))
rec.SetSeverity(otellog.SeverityInfo)
if status >= 500 {
rec.SetSeverity(otellog.SeverityError)
}
rec.AddAttributes(otellog.String("event", "http.request"), otellog.String("route", route), otellog.String("method", c.Request().Method), otellog.Int("status", status), otellog.String("request_id", c.Response().Header().Get("X-Request-Id")), otellog.String("trace_id", sc.TraceID().String()), otellog.String("span_id", sc.SpanID().String()))
logs.Emit(ctx, rec)
return nil
}
}