Files

293 lines
9.9 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"
"google.golang.org/grpc/credentials"
"gitea.privcloud.tech/dizi/mtusi2026lab7/internal/security/tlsconfig"
)
const (
defaultEnvironment = "lab"
defaultNamespace = "mtusi-highload"
)
type Config struct {
ServiceName string
Version string
InstanceID string
Endpoint string
Environment string
Namespace string
Insecure bool
TLSCAPath string
TLSCertificatePath string
TLSPrivateKeyPath string
TLSServerName string
}
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: strings.EqualFold(strings.TrimSpace(os.Getenv("OTEL_EXPORTER_OTLP_INSECURE")), "true"),
TLSCAPath: strings.TrimSpace(os.Getenv("OTEL_EXPORTER_OTLP_CERTIFICATE")),
TLSCertificatePath: strings.TrimSpace(os.Getenv("OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE")),
TLSPrivateKeyPath: strings.TrimSpace(os.Getenv("OTEL_EXPORTER_OTLP_CLIENT_KEY")),
TLSServerName: strings.TrimSpace(os.Getenv("OTEL_EXPORTER_OTLP_SERVER_NAME")),
}
}
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())
} else {
transportCredentials, err := telemetryCredentials(config)
if err != nil {
return nil, err
}
options = append(options, otlptracegrpc.WithTLSCredentials(transportCredentials))
}
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())
} else {
transportCredentials, err := telemetryCredentials(config)
if err != nil {
return nil, err
}
options = append(options, otlpmetricgrpc.WithTLSCredentials(transportCredentials))
}
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())
} else {
transportCredentials, err := telemetryCredentials(config)
if err != nil {
return nil, err
}
options = append(options, otlploggrpc.WithTLSCredentials(transportCredentials))
}
exporter, err := otlploggrpc.New(ctx, options...)
if err != nil {
return nil, fmt.Errorf("create OTLP log exporter: %w", err)
}
return exporter, nil
}
func telemetryCredentials(config Config) (credentials.TransportCredentials, error) {
tlsConfiguration, err := tlsconfig.LoadClient(tlsconfig.ClientConfig{
CAPath: config.TLSCAPath, CertificatePath: config.TLSCertificatePath,
PrivateKeyPath: config.TLSPrivateKeyPath, ServerName: config.TLSServerName,
})
if err != nil {
return nil, fmt.Errorf("load OTLP TLS configuration: %w", err)
}
return credentials.NewTLS(tlsConfiguration), 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
}