forked from mtusi2026/mtusi2026lab6
123 lines
4.8 KiB
Go
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
|
|
}
|
|
}
|