package telemetry import ( "context" "errors" "fmt" "log/slog" "net/http" "os" "strings" "time" "github.com/prometheus/client_golang/prometheus" "github.com/prometheus/client_golang/prometheus/collectors" "github.com/prometheus/client_golang/prometheus/promhttp" "go.opentelemetry.io/contrib/bridges/otelslog" otelruntime "go.opentelemetry.io/contrib/instrumentation/runtime" "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc" "go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc" "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc" otelprometheus "go.opentelemetry.io/otel/exporters/prometheus" "go.opentelemetry.io/otel/propagation" "go.opentelemetry.io/otel/sdk/log" "go.opentelemetry.io/otel/sdk/metric" "go.opentelemetry.io/otel/sdk/resource" "go.opentelemetry.io/otel/sdk/trace" semconv "go.opentelemetry.io/otel/semconv/v1.34.0" ) const ( defaultEnvironment = "lab" defaultNamespace = "mtusi-highload" ) type Config struct { ServiceName string Version string InstanceID string Endpoint string Environment string Namespace string Insecure bool } type Runtime struct { traces *trace.TracerProvider metrics *metric.MeterProvider logs *log.LoggerProvider logger *slog.Logger handler http.Handler } func ConfigFromEnvironment(serviceName, instanceID string) Config { resourceAttributes := parseResourceAttributes(os.Getenv("OTEL_RESOURCE_ATTRIBUTES")) return Config{ ServiceName: serviceName, Version: firstValue(os.Getenv("SERVICE_VERSION"), resourceAttributes["service.version"], "dev"), InstanceID: instanceID, Endpoint: strings.TrimSpace(os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT")), Environment: firstValue(os.Getenv("DEPLOYMENT_ENVIRONMENT"), resourceAttributes["deployment.environment.name"], defaultEnvironment), Namespace: firstValue(os.Getenv("SERVICE_NAMESPACE"), resourceAttributes["service.namespace"], defaultNamespace), Insecure: true, } } func parseResourceAttributes(raw string) map[string]string { result := make(map[string]string) for _, pair := range strings.Split(raw, ",") { key, value, found := strings.Cut(pair, "=") if found && strings.TrimSpace(key) != "" { result[strings.TrimSpace(key)] = strings.TrimSpace(value) } } return result } func firstValue(values ...string) string { for _, value := range values { if value = strings.TrimSpace(value); value != "" { return value } } return "" } func New(ctx context.Context, config Config) (*Runtime, error) { if err := config.validate(); err != nil { return nil, err } res, err := newResource(ctx, config) if err != nil { return nil, err } registry := prometheus.NewRegistry() prometheusReader, err := otelprometheus.New(otelprometheus.WithRegisterer(registry)) if err != nil { return nil, fmt.Errorf("create Prometheus reader: %w", err) } traceOptions := []trace.TracerProviderOption{trace.WithResource(res)} metricOptions := []metric.Option{metric.WithResource(res), metric.WithReader(prometheusReader)} logOptions := []log.LoggerProviderOption{log.WithResource(res)} if config.Endpoint != "" { traceExporter, err := newTraceExporter(ctx, config) if err != nil { return nil, err } metricExporter, err := newMetricExporter(ctx, config) if err != nil { return nil, err } logExporter, err := newLogExporter(ctx, config) if err != nil { return nil, err } traceOptions = append(traceOptions, trace.WithBatcher(traceExporter, trace.WithMaxQueueSize(2048), trace.WithMaxExportBatchSize(512), trace.WithBatchTimeout(time.Second), trace.WithExportTimeout(5*time.Second), )) metricOptions = append(metricOptions, metric.WithReader(metric.NewPeriodicReader( metricExporter, metric.WithInterval(5*time.Second), metric.WithTimeout(5*time.Second), ))) logOptions = append(logOptions, log.WithProcessor(log.NewBatchProcessor(logExporter, log.WithMaxQueueSize(2048), log.WithExportMaxBatchSize(512), log.WithExportInterval(time.Second), log.WithExportTimeout(5*time.Second), ))) } traces := trace.NewTracerProvider(traceOptions...) metrics := metric.NewMeterProvider(metricOptions...) logs := log.NewLoggerProvider(logOptions...) propagator := propagation.NewCompositeTextMapPropagator(propagation.TraceContext{}) otel.SetTracerProvider(traces) otel.SetMeterProvider(metrics) otel.SetTextMapPropagator(propagator) if err := otelruntime.Start(otelruntime.WithMeterProvider(metrics)); err != nil { return nil, fmt.Errorf("start Go runtime metrics: %w", err) } stdout := slog.NewJSONHandler(os.Stdout, nil) otelHandler := otelslog.NewHandler(config.ServiceName, otelslog.WithLoggerProvider(logs)) logger := slog.New(newCorrelationHandler(stdout, otelHandler)) registry.MustRegister(collectors.NewProcessCollector(collectors.ProcessCollectorOpts{})) return &Runtime{ traces: traces, metrics: metrics, logs: logs, logger: logger, handler: promhttp.HandlerFor(registry, promhttp.HandlerOpts{}), }, nil } func (c Config) validate() error { switch { case strings.TrimSpace(c.ServiceName) == "": return errors.New("telemetry service name is required") case strings.TrimSpace(c.InstanceID) == "": return errors.New("telemetry instance ID is required") case strings.TrimSpace(c.Environment) == "": return errors.New("telemetry environment is required") case strings.TrimSpace(c.Namespace) == "": return errors.New("telemetry service namespace is required") default: return nil } } func newResource(ctx context.Context, config Config) (*resource.Resource, error) { res, err := resource.New(ctx, resource.WithFromEnv(), resource.WithTelemetrySDK(), resource.WithHost(), resource.WithAttributes( semconv.ServiceName(config.ServiceName), semconv.ServiceVersion(config.Version), semconv.ServiceInstanceID(config.InstanceID), semconv.ServiceNamespace(config.Namespace), semconv.DeploymentEnvironmentName(config.Environment), ), ) if err != nil { return nil, fmt.Errorf("create telemetry resource: %w", err) } return res, nil } func newTraceExporter(ctx context.Context, config Config) (trace.SpanExporter, error) { var options []otlptracegrpc.Option if strings.Contains(config.Endpoint, "://") { options = append(options, otlptracegrpc.WithEndpointURL(config.Endpoint)) } else { options = append(options, otlptracegrpc.WithEndpoint(config.Endpoint)) } if config.Insecure { options = append(options, otlptracegrpc.WithInsecure()) } exporter, err := otlptracegrpc.New(ctx, options...) if err != nil { return nil, fmt.Errorf("create OTLP trace exporter: %w", err) } return exporter, nil } func newMetricExporter(ctx context.Context, config Config) (*otlpmetricgrpc.Exporter, error) { var options []otlpmetricgrpc.Option if strings.Contains(config.Endpoint, "://") { options = append(options, otlpmetricgrpc.WithEndpointURL(config.Endpoint)) } else { options = append(options, otlpmetricgrpc.WithEndpoint(config.Endpoint)) } if config.Insecure { options = append(options, otlpmetricgrpc.WithInsecure()) } exporter, err := otlpmetricgrpc.New(ctx, options...) if err != nil { return nil, fmt.Errorf("create OTLP metric exporter: %w", err) } return exporter, nil } func newLogExporter(ctx context.Context, config Config) (*otlploggrpc.Exporter, error) { var options []otlploggrpc.Option if strings.Contains(config.Endpoint, "://") { options = append(options, otlploggrpc.WithEndpointURL(config.Endpoint)) } else { options = append(options, otlploggrpc.WithEndpoint(config.Endpoint)) } if config.Insecure { options = append(options, otlploggrpc.WithInsecure()) } exporter, err := otlploggrpc.New(ctx, options...) if err != nil { return nil, fmt.Errorf("create OTLP log exporter: %w", err) } return exporter, nil } func (r *Runtime) Logger() *slog.Logger { return r.logger } func (r *Runtime) MeterProvider() *metric.MeterProvider { return r.metrics } func (r *Runtime) MetricsHandler() http.Handler { return r.handler } func (r *Runtime) Shutdown(ctx context.Context) error { var result error for _, shutdown := range []func(context.Context) error{r.logs.Shutdown, r.metrics.Shutdown, r.traces.Shutdown} { if err := shutdown(ctx); err != nil { result = errors.Join(result, err) } } return result }