forked from mtusi2026/mtusi2026lab7
253 lines
8.1 KiB
Go
253 lines
8.1 KiB
Go
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
|
|
}
|